extractor PR with clangcl tweaks

MSVC Fix
value_iterator::on_field_raw noexcept
2026-06-08 17:27:07 +00:00 · 2024-09-21 12:35:29 -04:00 · 2024-09-21 04:35:08 -10:00 · 2024-09-21 01:09:46 -10:00 · 2024-09-21 00:44:20 -10:00 · 2024-09-21 03:39:23 -07:00
368 changed files with 13455 additions and 168323 deletions
@@ -0,0 +1,316 @@
+version: 2.1
+
+
+# We constantly run out of memory so please do not use parallelism (-j, -j4).
+
+# Reusable image / compiler definitions
+executors:
+  gcc8:
+    docker:
+      - image: conanio/gcc8
+        environment:
+          CXX: g++-8
+          CC: gcc-8
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  gcc9:
+    docker:
+      - image: conanio/gcc9
+        environment:
+          CXX: g++-9
+          CC: gcc-9
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  gcc10:
+    docker:
+      - image: conanio/gcc10
+        environment:
+          CXX: g++-10
+          CC: gcc-10
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  clang10:
+    docker:
+      - image: conanio/clang10
+        environment:
+          CXX: clang++-10
+          CC: clang-10
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  clang9:
+    docker:
+      - image: conanio/clang9
+        environment:
+          CXX: clang++-9
+          CC: clang-9
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  clang6:
+    docker:
+      - image: conanio/clang60
+        environment:
+          CXX: clang++-6.0
+          CC: clang-6.0
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+# Reusable test commands (and initializer for clang 6)
+commands:
+  dependency_restore:
+    steps:
+      - restore_cache:
+          keys:
+            - cmake-cache-{{ checksum "dependencies/CMakeLists.txt" }}
+
+  dependency_cache:
+    steps:
+      - save_cache:
+          key: cmake-cache-{{ checksum "dependencies/CMakeLists.txt" }}
+          paths:
+            - dependencies/.cache
+
+  install_cmake:
+    steps:
+      - run: apt-get update -qq
+      - run: apt-get install -y cmake
+
+  cmake_prep:
+    steps:
+      - checkout
+      - run: mkdir -p build
+
+  cmake_build_cache:
+    steps:
+      - cmake_prep
+      - dependency_restore
+      - run: cmake  -DSIMDJSON_DEVELOPER_MODE=ON $CMAKE_FLAGS -DCMAKE_INSTALL_PREFIX:PATH=destination -B build .
+      - dependency_cache # dependencies are produced in the configure step
+
+  cmake_build:
+    steps:
+      - cmake_build_cache
+      - run: cmake  --build build
+
+  cmake_test:
+    steps:
+      - cmake_build
+      - run: |
+          cd build &&
+          tools/json2json -h &&
+          ctest $CTEST_FLAGS -L acceptance &&
+          ctest $CTEST_FLAGS -LE acceptance -LE explicitonly
+
+  cmake_assert_test:
+    steps:
+      - run: |
+          cd build &&
+          tools/json2json -h &&
+          ctest $CTEST_FLAGS -L assert
+
+  cmake_test_all:
+    steps:
+      - cmake_build
+      - run: |
+          cd build &&
+          tools/json2json -h &&
+          ctest $CTEST_FLAGS -DSIMDJSON_IMPLEMENTATION="haswell;westmere;fallback" -L acceptance -LE per_implementation &&
+          SIMDJSON_FORCE_IMPLEMENTATION=haswell ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
+          SIMDJSON_FORCE_IMPLEMENTATION=westmere ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
+          SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
+          ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
+
+
+  cmake_perftest:
+    steps:
+      - cmake_build_cache
+      - run: |
+          cmake -DSIMDJSON_ENABLE_DOM_CHECKPERF=ON --build  build --target checkperf &&
+          cd build &&
+          ctest --output-on-failure -R checkperf
+
+  # we not only want cmake to build and run tests, but we want also a successful installation from which we can build, link and run programs
+  cmake_install_test: # this version builds, install, test and then verify from the installation
+    steps:
+      - run: cd build && make install
+      - run: echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Ibuild/destination/include -Lbuild/destination/lib -std=c++17 -Wl,-rpath,build/destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json
+
+  cmake_installed_test_cxx20: # assuming that it was installed, this tries to build using C++20
+    steps:
+      - run: echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Ibuild/destination/include -Lbuild/destination/lib -std=c++20 -Wl,-rpath,build/destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json
+
+jobs:
+
+  # static
+  justlib-gcc10:
+    description: Build just the library, install it and do a basic test
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_JUST_LIBRARY=ON }
+    steps: [ cmake_build, cmake_install_test, cmake_installed_test_cxx20 ]
+  assert-gcc10:
+    description: Build the library with asserts on, install it and run tests
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DCMAKE_CXX_FLAGS_RELEASE=-O3 }
+    steps: [ cmake_test, cmake_assert_test ]
+  assert-clang10:
+    description: Build just the library, install it and do a basic test
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DCMAKE_CXX_FLAGS_RELEASE=-O3 }
+    steps: [ cmake_test, cmake_assert_test ]
+  gcc10-perftest:
+    description: Build and run performance tests on GCC 10 and AVX 2 with a cmake static build, this test performance regression
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_perftest ]
+  gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake static build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
+  clang6:
+    description: Build and run tests on clang 6 and AVX 2 with a cmake static build
+    executor: clang6
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+  clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake static build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON  -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
+  # libcpp
+  libcpp-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake static build and libc++
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_USE_LIBCPP=ON  -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
+  # sanitize
+  sanitize-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  sanitize-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  threadsanitize-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE_THREADS=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  threadsanitize-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON  -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE_THREADS=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  # dynamic
+  dynamic-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake dynamic build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON }
+    steps: [ cmake_test, cmake_install_test ]
+  dynamic-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake dynamic build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON }
+    steps: [ cmake_test, cmake_install_test ]
+
+  # unthreaded
+  unthreaded-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 *without* threads
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+  unthreaded-clang10:
+    description: Build and run tests on Clang 10 and AVX 2 *without* threads
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+
+  # noexcept
+  noexcept-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with exceptions off
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+  noexcept-clang10:
+    description: Build and run tests on Clang 10 and AVX 2 with exceptions off
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+
+  #
+  # Misc.
+  #
+
+  # make (test and checkperf)
+  arch-haswell-gcc10:
+    description: Build, run tests and check performance on GCC 10 with -march=haswell
+    executor: gcc10
+    environment: { CXXFLAGS: -march=haswell }
+    steps: [ cmake_test ]
+  arch-nehalem-gcc10:
+    description: Build, run tests and check performance on GCC 10 with -march=nehalem
+    executor: gcc10
+    environment: { CXXFLAGS: -march=nehalem }
+    steps: [ cmake_test ]
+  sanitize-haswell-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
+    executor: gcc10
+    environment: {  CXXFLAGS: -march=haswell, CMAKE_FLAGS: -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  sanitize-haswell-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
+    executor: clang10
+    environment: { CXXFLAGS: -march=haswell, CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON  -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+
+workflows:
+  version: 2.1
+  build_and_test:
+    jobs:
+      # full multi-implementation tests
+      #- gcc7 tested on GitHub actions
+      - gcc10 # do not delete this as it tests our performance
+      - clang6
+      #- clang10 # this gets tested a lot below
+
+      # libc++
+      - libcpp-clang10
+
+      # full single-implementation tests
+      - sanitize-gcc10
+      - sanitize-clang10
+      - threadsanitize-gcc10
+      - threadsanitize-clang10
+      - dynamic-gcc10
+      - dynamic-clang10
+      - unthreaded-gcc10
+      - unthreaded-clang10
+
+      # no exceptions
+      - noexcept-gcc10
+      - noexcept-clang10
+
+      # quicker make single-implementation tests
+      - arch-haswell-gcc10
+      - arch-nehalem-gcc10
+
+
+      # sanitized single-implementation tests
+      - sanitize-haswell-gcc10
+      - sanitize-haswell-clang10
+
+      # testing "just the library"
+      - justlib-gcc10
+
+      # testing asserts
+      - assert-gcc10
+      - assert-clang10
+
+      # TODO add windows: https://circleci.com/docs/2.0/configuration-reference/#windows
@@ -9,8 +9,7 @@ assignees: ''

 Before submitting an issue, please ensure that you have read the documentation:

-* Basics is an overview of how to use simdjson and its APIs to parse JSON: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
-* Builder is an overview of how to use simdjson to generate JSON: https://github.com/simdjson/simdjson/blob/master/doc/builder.md
+* Basics is an overview of how to use simdjson and its APIs: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
 * Performance shows some more advanced scenarios and how to tune for them: https://github.com/simdjson/simdjson/blob/master/doc/performance.md
 * Contributing: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
 * We follow the [JSON specification as described by RFC 8259](https://www.rfc-editor.org/rfc/rfc8259.txt) (T. Bray, 2017). If you wish to support features that are not part of RFC 8259, then you should not refer to your issue as a bug.
@@ -29,9 +28,6 @@ We accept the identification of an issue by a sanitizer or some checker tool (e.

 We recommend that you run your tests using different optimization levels. In particular, we recommend your run tests with the simdjson library and you code compiled in debug mode. The simdjson then sets the SIMDJSON_DEVELOPMENT_CHECKS macro to 1, and this triggers additional checks on your code and on the internals of the library. If possible, we recommend that you run tests with sanitizers (e.g., see [No more leaks with sanitize flags in gcc and clang](https://lemire.me/blog/2016/04/20/no-more-leaks-with-sanitize-flags-in-gcc-and-clang/)).  You can compile the library with sanitizers for debugging purposes (e.g., set SIMDJSON_SANITIZE to ON using CMake), but you should also turn on sanitizers on your own code. You may also use tools like valgrind or the commercial equivalent.

-Mixing debug and release simdjson code is unsafe: you either build all your code using simdjson in
-release mode or all of it in debug mode.
-
 Before reporting a bug, please ensure that you have read our documentation.

 **To Reproduce**
@@ -41,7 +37,7 @@ If we cannot reproduce the issue, then we cannot address it. Note that a stack t

 It should be possible to trigger the bug by using solely simdjson with our default build setup. If you can only observe the bug within some specific context, with some other software, please reduce the issue first.

-**simdjson release**
+**simjson release**

 Unless you plan to contribute to simdjson, you should only work from releases. Please be mindful that our main branch may have additional features, bugs and documentation items.

@@ -58,9 +54,6 @@ We support up-to-date 64-bit ARM and x64 FreeBSD, macOS, Windows and Linux syste
 * We do not support unreleased or experimental compilers. If you encounter an issue with a
 pre-release version of a compiler, do not report it as a bug to simdjson. However, we always
 invite contributions either in the form an analysis or of a code contribution.
-* Vendors (e.g., Apple and Microsoft) stop supporting old systems. Once a compiler system is no longer supported by its vendor, we no longer support it. We will gladly accept code contributions, but we do not consider it a *bug* if you have issues with an obsolete compiler systems. This policy extends to obsolete standard libraries, linkers and other build tools. Please do not report it as an issue. If you cannot resolve the issue yourself, we encourage you to reach out to the vendor for legacy support.
-
-Under Windows, we support Visual Studio (both with LLVM and without). We do not support MinGW and other alternate compiler systems. Windows users should be aware that there [is a long-running bug with GCC under Windows](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412).

 **Indicate whether you are willing or able to provide a bug fix as a pull request**

@@ -9,8 +9,7 @@ assignees: ''

 Before submitting an issue, please ensure that you have read the documentation:

-* Basics is an overview of how to use simdjson and its APIs to parse JSON: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
-* Builder is an overview of how to use simdjson to generate JSON: https://github.com/simdjson/simdjson/blob/master/doc/builder.md
+* Basics is an overview of how to use simdjson and its APIs: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
 * Performance shows some more advanced scenarios and how to tune for them: https://github.com/simdjson/simdjson/blob/master/doc/performance.md
 * Contributing: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
 * We follow the [JSON specification as described by RFC 8259](https://www.rfc-editor.org/rfc/rfc8259.txt) (T. Bray, 2017).
@@ -9,8 +9,7 @@ assignees: ''

 Before submitting an issue, please ensure that you have read the documentation:

-* Basics is an overview of how to use simdjson and its APIs to parse JSON: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
-* Builder is an overview of how to use simdjson to generate JSON: https://github.com/simdjson/simdjson/blob/master/doc/builder.md
+* Basics is an overview of how to use simdjson and its APIs: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
 * Performance shows some more advanced scenarios and how to tune for them: https://github.com/simdjson/simdjson/blob/master/doc/performance.md
 * Contributing: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
 * We follow the [JSON specification as described by RFC 8259](https://www.rfc-editor.org/rfc/rfc8259.txt) (T. Bray, 2017).
@@ -1,54 +1,8 @@
-Short title (summary):
-
-Description
- What did you change and why? (1-3 sentences)
- Issue reproduced / related issue: link the issue if relevant (e.g. #123)
-
-Type of change
- [ ] Bug fix
- [ ] Optimization
- [ ] New feature
- [ ] Refactor / cleanup
- [ ] Documentation / tests
- [ ] Other (please describe):
-
-How to verify / test
- Add additional tests to verify bugs or new features.
- If you claim performance gains, you should provide benchmark numbers using high quality benchmarking code.


-Please read before contributing:
- CONTRIBUTING: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
- HACKING: https://github.com/simdjson/simdjson/blob/master/HACKING.md
- AI Usage Policy: https://github.com/simdjson/simdjson/blob/master/AI_USAGE_POLICY.md
+Our tests check whether you have introduced trailing white space. If such a test fails, please check the "artifacts button" above, which if you click it gives a link to a downloadable file to help you identify the issue. You can also run scripts/remove_trailing_whitespace.sh locally if you have a bash shell and the sed command available on your system.

+If you plan to contribute to simdjson, please read our

-If you can, we recommend running our tests with the sanitizers turned on.
-For non-Visual Studio users, it is as easy as doing:
-
-
-
-```bash
-cmake -B build -D SIMDJSON_SANITIZE=ON -D SIMDJSON_DEVELOPER_MODE=ON
-cmake --build build
-ctest --test-dir build
-```
-
-
-Our CI checks, among other things, for trailing whitespace. If a test fails for that reason,
-use the "artifacts" button to download the artifact and inspect the problematic lines,
-or run `scripts/remove_trailing_whitespace.sh` locally if you have a bash shell and `sed`.
-
-
-Checklist before submitting
- [ ] I added/updated tests covering my change (if applicable)
- [ ] Code builds locally and passes my check
- [ ] Documentation / README updated if needed
- [ ] Commits are atomic and messages are clear
- [ ] I linked the related issue (if applicable)
-
-Final notes
- For large PRs, prefer smaller incremental PRs or request staged review.
-
-Thanks for the contribution!
-
+CONTRIBUTING guide: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md and our
+HACKING guide: https://github.com/simdjson/simdjson/blob/master/HACKING.md
@@ -1,29 +0,0 @@
-name: Ubuntu aarch64 (GCC 13)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v3
-        name: Test
-        id: runcmd
-        with:
-          arch: aarch64
-          distro: ubuntu_latest
-          githubToken: ${{ github.token }}
-          install: |
-            apt-get update -q -y
-            apt-get install -y cmake make g++
-          run: |
-            cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
-            cmake --build build -j=2
-            ctest --output-on-failure --test-dir build
@@ -17,7 +17,7 @@ jobs:
        fuzz-seconds: 600
        dry-run: false
    - name: Upload Crash
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v1
      if: failure() && steps.build.outcome == 'success'
      with:
        name: artifacts
@@ -1,14 +1,9 @@
 name: Doxygen GitHub Pages

 on:
-  release:
-    # Trigger when a release object is created and when it's published.
-    # Some GitHub flows create a release object then publish it later; include both.
-    types: [created, published]
-  # Also trigger on tag creation pushes so releasing via Git tags still runs the workflow
  push:
-    tags:
-      - "v*"  # common release tag pattern like v1.2.3
+    branches:
+      - master
  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:

@@ -33,7 +28,7 @@ jobs:
      - name: Generate Doxygen Documentation
        run: doxygen
      - name: Deploy to GitHub Pages
-        uses: peaceiris/actions-gh-pages@v4
+        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: doc/api/html
@@ -1,17 +0,0 @@
-on: [push, pull_request]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
-      - uses: mymindstorm/setup-emsdk@6ab9eb1bda2574c4ddb79809fc9247783eaf9021 # v14
-      - name: Verify
-        run: emcc -v
-      - name: Checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v3.6.0
-      - name: Configure
-        run: emcmake cmake -B build
-      - name: Build # We build but do not test
-        run: cmake --build build
@@ -4,7 +4,7 @@ on: [push, pull_request]

 jobs:
  whitespace:
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v4
      - name: Remove whitespace and check the diff
@@ -24,7 +24,7 @@ jobs:
             echo "no trailing whitespace found, good!"
          fi
      - name: Archive whitespace patch
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
        if: always()
        with:
          name: whitespace-patch
@@ -24,7 +24,7 @@ jobs:
      implementations: haswell westmere fallback
      UBSAN_OPTIONS: halt_on_error=1
      MAXLEN: -max_len=4000
-      CLANGVERSION: 19
+      CLANGVERSION: 15
      # which optimization level to use for the sanitizer build (see build_fuzzer.variants.sh)
      OPTLEVEL: -O3

@@ -125,7 +125,7 @@ jobs:
        done

    - name: Save the corpus as a github artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
      with:
        name: corpus
        path: corpus.tar
@@ -148,7 +148,7 @@ jobs:
      run: tar cf valgrind.tar valgrind-*.txt

    - name: Save valgrind output as a github artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
      if: always()
      with:
        name: valgrindresults
@@ -156,7 +156,7 @@ jobs:
        if-no-files-found: ignore

    - name: Archive any crashes as an artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
      if: always()
      with:
        name: crashes
@@ -18,13 +18,13 @@ jobs:
        run: |
          mkdir builddebug &&
          cd builddebug &&
-          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
+          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
          ctest --output-on-failure -LE explicitonly -j   &&
          cd .. &&
          mkdir build &&
          cd build &&
-          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
          cmake --build .   &&
          ctest --output-on-failure -LE explicitonly -j   &&
          cmake --install . &&
@@ -35,7 +35,7 @@ jobs:
        run: |
          mkdir buildshared &&
          cd buildshared &&
-          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=destination -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
          cmake --build .   &&
          ctest --output-on-failure -LE explicitonly -j   &&
          cmake --install . &&
@@ -20,7 +20,7 @@ jobs:
          - msystem: "MINGW64"
            install: mingw-w64-x86_64-libxml2 mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
            type: Debug
-          - msystem: "MINGW64"
+            - msystem: "MINGW64"
            install: mingw-w64-x86_64-libxml2 mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
            type: RelWithDebInfo
    env:
@@ -22,7 +22,7 @@ jobs:
          - msystem: "MINGW64"
            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
            type: Debug
-          - msystem: "MINGW64"
+            - msystem: "MINGW64"
            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
            type: RelWithDebInfo
    env:
@@ -43,6 +43,6 @@ jobs:
        run: |
          mkdir build
          cd build
-          cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_BUILD_TYPE=${{ matrix.type }} -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_DO_NOT_USE_THREADS_NO_MATTER_WHAT=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..
+          cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_BUILD_TYPE=${{ matrix.type }} -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_DO_NOT_USE_THREADS_NO_MATTER_WHAT=ON ..
          cmake --build . --verbose
          ctest -j4 --output-on-failure -LE explicitonly
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v3
+      - uses: uraimo/run-on-arch-action@v2
        name: Test
        id: runcmd
        with:
@@ -24,6 +24,6 @@ jobs:
            apt-get update -q -y
            apt-get install -y cmake make g++
          run: |
-            cmake -DCMAKE_BUILD_TYPE=Release -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF  -B build
+            cmake -DCMAKE_BUILD_TYPE=Release -B build
            cmake --build build -j=2
            ctest --output-on-failure --test-dir build
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v3
+      - uses: uraimo/run-on-arch-action@v2
        name: Test
        id: runcmd
        with:
@@ -24,6 +24,6 @@ jobs:
            apt-get update -q -y
            apt-get install -y cmake make g++
          run: |
-            cmake -DCMAKE_BUILD_TYPE=Release -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
+            cmake -DCMAKE_BUILD_TYPE=Release -B build
            cmake --build build -j=2
            ctest --output-on-failure --test-dir build
@@ -1,29 +0,0 @@
-name: Ubuntu rvv VLEN=1024 (clang 18)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install packages
-      run: |
-        sudo apt-get update -q -y
-        sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-18
-    - name: Build
-      run: |
-        CC=clang-18 CXX=clang++-18 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvbb" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
-        cmake --build build/ -j$(nproc) --config Release
-    - name: Test VLEN=1024
-      run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
-        QEMU_CPU="rv64,v=on,zvbb=on,vlen=1024,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
-        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)
@@ -1,24 +0,0 @@
-name: Ubuntu rvv VLEN=128 (clang 17)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install packages
-      run: |
-        sudo apt-get update -q -y
-        sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-17
-    - name: Build
-      run: |
-        CC=clang-17 CXX=clang++-17 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
-        cmake --build build/ -j$(nproc) --config Release
@@ -1,39 +0,0 @@
-name: Ubuntu rvv VLEN=128 (clang 20)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install packages
-      run: |
-        sudo apt-get update -q -y
-        sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-20
-    - name: Build
-      run: |
-        CC=clang-20 CXX=clang++-20 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
-        cmake --build build/ -j$(nproc) --config Release
-    - name: Test VLEN=128
-      run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
-        QEMU_CPU="rv64,v=on,vlen=128,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
-        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)
-    - name: Build VLS
-      run: |
-        CC=clang-20 CXX=clang++-20 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvl128b_zba_zbb_zbc -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build-vls
-        cmake --build build-vls/ -j$(nproc) --config Release
-    - name: Test VLEN=128 VLS
-      run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
-        QEMU_CPU="rv64,v=on,zba=on,zbb=on,zbc=on,vlen=128,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
-        ctest --timeout 1800 --output-on-failure --test-dir build-vls -j $(nproc)
@@ -1,39 +0,0 @@
-name: Ubuntu rvv VLEN=256 (gcc 14)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install packages
-      run: |
-        sudo apt-get update -q -y
-        sudo apt-get install -y cmake make g++-14-riscv64-linux-gnu qemu-user-static
-    - name: Build
-      run: |
-        CC=riscv64-linux-gnu-gcc-14 CXX=riscv64-linux-gnu-g++-14 CFLAGS=-march=rv64gcv CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
-        cmake --build build/ -j$(nproc) --config Release
-    - name: Test VLEN=256
-      run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
-        QEMU_CPU="rv64,v=on,zvbb=on,vlen=256,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
-        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)
-    - name: Build VLS
-      run: |
-        CC=riscv64-linux-gnu-gcc-14 CXX=riscv64-linux-gnu-g++-14 CFLAGS="-march=rv64gcv_zvl256b -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build-vls
-        cmake --build build-vls/ -j$(nproc) --config Release
-    - name: Test VLEN=256 VLS
-      run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
-        QEMU_CPU="rv64,v=on,zvbb=on,vlen=256,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
-        ctest --timeout 1800 --output-on-failure --test-dir build-vls -j $(nproc)
@@ -1,39 +0,0 @@
-name: Ubuntu rvv VLEN=512 (clang 19)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install packages
-      run: |
-        sudo apt-get update -q -y
-        sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-19
-    - name: Build
-      run: |
-        CC=clang-19 CXX=clang++-19 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
-        cmake --build build/ -j$(nproc) --config Release
-    - name: Test VLEN=512
-      run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
-        QEMU_CPU="rv64,v=on,vlen=512,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
-        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)
-    - name: Build VLS
-      run: |
-        CC=clang-19 CXX=clang++-19 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvl512b_zba_zbb_zbc -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build-vls
-        cmake --build build-vls/ -j$(nproc) --config Release
-    - name: Test VLEN=512 VLS
-      run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
-        QEMU_CPU="rv64,v=on,zba=on,zbb=on,zbc=on,vlen=512,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
-        ctest --timeout 1800 --output-on-failure --test-dir build-vls -j $(nproc)
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v3
+      - uses: uraimo/run-on-arch-action@v2
        name: Test
        id: runcmd
        with:
@@ -24,6 +24,6 @@ jobs:
            apt-get update -q -y
            apt-get install -y cmake make g++
          run: |
-            cmake -DCMAKE_BUILD_TYPE=Release  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
+            cmake -DCMAKE_BUILD_TYPE=Release -B build
            cmake --build build -j=2
            ctest --output-on-failure --test-dir build
@@ -1,4 +1,4 @@
-name: Performance check on Ubuntu 24.04 CI (GCC 13)
+name: Performance check on Ubuntu 20.04 CI (GCC 9)

 on:
  push:
@@ -13,7 +13,7 @@ jobs:
    if: >-
      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v4
      - uses: actions/cache@v4
@@ -24,6 +24,6 @@ jobs:
        run: |
          mkdir build &&
          cd build &&
-          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_ENABLE_DOM_CHECKPERF=ON -DCMAKE_CXX_FLAGS="-Werror=old-style-cast -pedantic -Wpedantic" -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
+          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_ENABLE_DOM_CHECKPERF=ON -DCMAKE_CXX_FLAGS="-Werror=old-style-cast -pedantic -Wpedantic" -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
          cmake --build . --target checkperf  &&
          ctest --output-on-failure -R checkperf
@@ -0,0 +1,38 @@
+name: Ubuntu 20.04 CI (GCC 8)
+
+on: [push, pull_request]
+
+jobs:
+  ubuntu-build:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    runs-on: ubuntu-20.04
+    env:
+      CXX: g++-8
+      CC: gcc-8
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Install GCC 8
+        run: sudo apt-get install -y g++-8
+      - name: Use cmake
+        run: |
+          mkdir builddebug &&
+          cd builddebug &&
+          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cd .. &&
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cmake --install . &&
+          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
+          cd ../tests/installation_tests/find &&
+          mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build/destination .. &&  cmake --build .
@@ -1,4 +1,4 @@
-name: Ubuntu 24.04 CI (GCC 13) without exceptions
+name: Ubuntu 20.04 CI (GCC 9) without exceptions

 on: [push, pull_request]

@@ -7,7 +7,7 @@ jobs:
    if: >-
      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v4
      - uses: actions/cache@v4
@@ -18,17 +18,17 @@ jobs:
        run: |
          mkdir builddebug &&
          cd builddebug &&
-          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
+          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
          ctest --output-on-failure -LE explicitonly -j   &&
          cd .. &&
          mkdir build &&
          cd build &&
-          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
+          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
          cmake --build .   &&
          ctest --output-on-failure -LE explicitonly -j   &&
          make install  &&
          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
          mkdir testfindpackage &&
          cd testfindpackage &&
-          echo -e 'cmake_minimum_required(VERSION 3.14)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .
+          echo -e 'cmake_minimum_required(VERSION 3.1)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .
@@ -1,4 +1,4 @@
-name: Ubuntu 24.04 CI (GCC 13) Without Threads
+name: Ubuntu 20.04 CI (GCC 9) Without Threads

 on: [push, pull_request]

@@ -7,7 +7,7 @@ jobs:
    if: >-
      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v4
      - uses: actions/cache@v4
@@ -18,17 +18,17 @@ jobs:
        run: |
          mkdir builddebug &&
          cd builddebug &&
-          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF  -DSIMDJSON_ENABLE_THREADS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
+          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF  -DSIMDJSON_ENABLE_THREADS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
          ctest --output-on-failure -LE explicitonly -j   &&
          cd .. &&
          mkdir build &&
          cd build &&
-          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_ENABLE_THREADS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
+          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_ENABLE_THREADS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
          cmake --build .   &&
          ctest --output-on-failure -LE explicitonly -j   &&
          make install  &&
          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
          mkdir testfindpackage &&
          cd testfindpackage &&
-          echo -e 'cmake_minimum_required(VERSION 3.14)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .
+          echo -e 'cmake_minimum_required(VERSION 3.1)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .
@@ -1,13 +1,13 @@
-name: Ubuntu 24.04 CI (GCC 13) With Memory Sanitizer
+name: Ubuntu 20.04 CI (GCC 9) With Memory Sanitizer

 on: [push, pull_request]

 jobs:
-  ubuntu-build-address-sanitizer:
+  ubuntu-build-address-sanitizier:
    if: >-
      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v4
      - uses: actions/cache@v4
@@ -18,14 +18,14 @@ jobs:
        run: |
          mkdir builddebug &&
          cd builddebug &&
-          cmake -DSIMDJSON_SANITIZE=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
+          cmake -DSIMDJSON_SANITIZE=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
          ctest --output-on-failure -LE explicitonly -j
  ubuntu-build-undefined-sanitizer:
    if: >-
      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v4
      - uses: actions/cache@v4
@@ -36,6 +36,6 @@ jobs:
        run: |
          mkdir builddebugundefsani &&
          cd builddebugundefsani &&
-          cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
+          cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
          ctest --output-on-failure -LE explicitonly -j
@@ -0,0 +1,47 @@
+name: Ubuntu 20.04 CI (GCC 9)
+
+on: [push, pull_request]
+
+jobs:
+  ubuntu-build:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake to build just the library
+        run: |
+          mkdir buildjustlib &&
+          cd buildjustlib &&
+          cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_DEVELOPER_MODE=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          cmake --install . &&
+          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp &&
+          c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson &&
+          cd ../tests/installation_tests/find &&
+          mkdir buildjustlib &&
+          cd buildjustlib &&
+          cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../buildjustlib/destination .. &&
+          cmake --build .
+      - name: Use cmake
+        run: |
+          mkdir builddebug &&
+          cd builddebug &&
+          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cd .. &&
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cmake --install . &&
+          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
+          cd ../tests/installation_tests/find &&
+          mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build/destination .. &&  cmake --build .
@@ -18,6 +18,6 @@ jobs:
        run: |
          mkdir build &&
          cd build &&
-          CXX=clang++-13 cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
+          CXX=clang++-13 cmake -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
          cmake --build .   &&
          ctest --output-on-failure -LE explicitonly -j
@@ -14,52 +14,20 @@ jobs:
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
-
-      - name: Configure Debug Build
+      - name: Use cmake
        run: |
-          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20 -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -B builddebug
-
-      - name: Compile Debug Build
-        run: |
-          cmake --build builddebug
-
-      - name: Test Debug Build
-        run: |
-          ctest --output-on-failure -LE explicitonly -j --test-dir builddebug
-
-      - name: Configure Release Build
-        run: |
-          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20 -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination -B build
-
-      - name: Compile Release Build
-        run: |
-          cmake --build build
-
-      - name: Test Release Build
-        run: |
-          ctest --output-on-failure -LE explicitonly -j --test-dir build
-
-      - name: Install Release Build
-        run: |
-          cmake --install build
-
-      - name: Generate Example Code
-        run: |
-          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp
-
-      - name: Compile Example Code
-        run: |
-          c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson
-
-      - name: Run Example Code
-        run: |
-          ./linkandrun jsonexamples/twitter.json
-
-      - name: Configure Find Tests
-        run: |
-          cd tests/installation_tests/find && \
-          cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../destination -B build
-
-      - name: Compile Find Tests
-        run: |
-          cd tests/installation_tests/find && cmake --build build
+          mkdir builddebug &&
+          cd builddebug &&
+          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20 -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cd .. &&
+          mkdir build &&
+          cd build &&
+          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cmake --install . &&
+          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
+          cd ../tests/installation_tests/find &&
+          mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build/destination .. &&  cmake --build .
@@ -19,6 +19,6 @@ jobs:
        run: |
          mkdir build &&
          cd build &&
-          CXX=g++-12 cmake -DCMAKE_BUILD_TYPE=Debug  -DSIMDJSON_GLIBCXX_ASSERTIONS=ON -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
+          CXX=g++-12 cmake -DCMAKE_BUILD_TYPE=Debug  -DSIMDJSON_GLIBCXX_ASSERTIONS=ON -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
          cmake --build .   &&
          ctest . -E avoid_
@@ -18,7 +18,7 @@ jobs:
        run: |
          mkdir build &&
          cd build &&
-          CXX=g++-12 cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE_THREADS=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
+          CXX=g++-12 cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE_THREADS=ON ..  &&
          cmake --build . --target document_stream_tests  --target ondemand_document_stream_tests --target parse_many_test  &&
          ctest --output-on-failure  -R parse_many_test  &&
          ctest --output-on-failure  -R document_stream_tests
@@ -1,22 +0,0 @@
-name: Ubuntu 24.04 CI (CXX 20, noexcept)
-
-on: [push, pull_request]
-jobs:
-  ubuntu-build:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-24.04
-    strategy:
-      matrix:
-        cxx: [g++-13, clang++-16]
-    steps:
-      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
-      - name: Prepare
-        run: cmake -DSIMDJSON_CXX_STANDARD=20 -DSIMDJSON_EXCEPTIONS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
-        env:
-          CXX: ${{matrix.cxx}}
-      - name: Build
-        run: cmake --build build -j=2
-      - name: Test
-        run: ctest --output-on-failure --test-dir build
@@ -1,22 +0,0 @@
-name: Ubuntu 24.04 CI (CXX 20)
-
-on: [push, pull_request]
-jobs:
-  ubuntu-build:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-24.04
-    strategy:
-      matrix:
-        cxx: [g++-13, clang++-16]
-    steps:
-      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
-      - name: Prepare
-        run: cmake -DSIMDJSON_CXX_STANDARD=20 -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
-        env:
-          CXX: ${{matrix.cxx}}
-      - name: Build
-        run: cmake --build build -j=2
-      - name: Test
-        run: ctest --output-on-failure --test-dir build
@@ -16,7 +16,7 @@ jobs:
    steps:
      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
      - name: Prepare
-        run: cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE=${{matrix.sanitizer}} -DBUILD_SHARED_LIBS=${{matrix.shared}} -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
+        run: cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE=${{matrix.sanitizer}} -DBUILD_SHARED_LIBS=${{matrix.shared}}  -B build
        env:
          CXX: ${{matrix.cxx}}
      - name: Build
@@ -10,6 +10,7 @@ jobs:
       fail-fast: false
       matrix:
         include:
+           - {arch: ARM}
           - {arch: ARM64}
           - {arch: ARM64EC}
     steps:
@@ -17,5 +18,5 @@ jobs:
         uses: actions/checkout@v4
       - name: Use cmake
         run: |
-           cmake -A ${{ matrix.arch }} -DCMAKE_SYSTEM_VERSION="10.0.22621.0" -DCMAKE_CROSSCOMPILING=1 -DSIMDJSON_DEVELOPER_MODE=ON -D SIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_EXCEPTIONS=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build  &&
-           cmake --build build --verbose
+           cmake -A ${{ matrix.arch }} -DCMAKE_SYSTEM_VERSION="10.0.22621.0" -DCMAKE_CROSSCOMPILING=1 -DSIMDJSON_DEVELOPER_MODE=ON -D SIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_EXCEPTIONS=OFF -B build  &&
+           cmake --build build --verbose
@@ -22,7 +22,7 @@ jobs:
      uses: actions/checkout@v4
    - name: Configure
      run: |
-        cmake -DSIMDJSON_CXX_STANDARD=20 -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
+        cmake -DSIMDJSON_CXX_STANDARD=20 -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
    - name: Build Debug
      run: cmake --build build --config Debug --verbose
    - name: Build Release
@@ -1,30 +0,0 @@
-name: VS17-CI-SANITIZE
-
-on: [push, pull_request]
-
-jobs:
-  ci:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    name: windows-vs17
-    runs-on: windows-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Debug}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Release}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: RelWithDebInfo}
-    steps:
-    - name: checkout
-      uses: actions/checkout@v4
-    - name: Configure
-      run: |
-        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSANITIZE=ON -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
-    - name: Build
-      run: cmake --build build --config ${{matrix.build_type}} --verbose
-    - name: Run tests
-      run: |
-        cd build
-        ctest -C ${{matrix.build_type}}  -LE explicitonly  --output-on-failure
@@ -26,15 +26,15 @@ jobs:
      run: |
        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
    - name: Build Debug
-      run: cmake --build build --config ${{matrix.build_type}} --verbose
+      run: cmake --build build --config ${{build_type}} --verbose
    - name: Run tests
      run: |
        cd build
-        ctest -C ${{matrix.build_type}}  -LE explicitonly  --output-on-failure
+        ctest -C ${{build_type}}  -LE explicitonly  --output-on-failure
    - name: Install
      run: |
-        cmake --install build --config ${{matrix.build_type}}
+        cmake --install build --config ${{build_type}}
    - name: Test Installation
      run: |
        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
-        cmake --build build_install_test --config ${{matrix.build_type}}
+        cmake --build build_install_test --config ${{build_type}}
@@ -1,37 +0,0 @@
-name: VS17-CLANG-CI
-
-on: [push, pull_request]
-
-jobs:
-  ci:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    name: windows-vs17
-    runs-on: windows-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - {gen: Visual Studio 17 2022, arch: x64, build_type: Debug}
-          - {gen: Visual Studio 17 2022, arch: x64, build_type: Release}
-          - {gen: Visual Studio 17 2022, arch: x64, build_type: RelWithDebInfo}
-    steps:
-    - name: checkout
-      uses: actions/checkout@v4
-    - name: Configure
-      run: |
-        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -T ClangCL -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
-    - name: Build
-      run: cmake --build build --config ${{matrix.build_type}} --verbose
-    - name: Run tests
-      run: |
-        cd build
-        ctest -C ${{matrix.build_type}}  -LE explicitonly  --output-on-failure
-    - name: Install
-      run: |
-        cmake --install build --config ${{matrix.build_type}}
-    - name: Test Installation
-      run: |
-        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
-        cmake --build build_install_test --config ${{matrix.build_type}}
@@ -13,15 +13,15 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - {gen: Visual Studio 17 2022, arch: x64, build_type: Debug}
-          - {gen: Visual Studio 17 2022, arch: x64, build_type: Release}
-          - {gen: Visual Studio 17 2022, arch: x64, build_type: RelWithDebInfo}
+          - {gen: Visual Studio 17 2022, arch: x64, build_type: Debug, cxx: 17}
+          - {gen: Visual Studio 17 2022, arch: x64, build_type: Debug, cxx: 20}
+          - {gen: Visual Studio 17 2022, arch: x64, build_type: Release, cxx: 17}
    steps:
    - name: checkout
      uses: actions/checkout@v4
    - name: Configure
      run: |
-        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -T ClangCL -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_CXX_STANDARD=${{matrix.cxx}} -T ClangCL -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
    - name: Build
      run: cmake --build build --config ${{matrix.build_type}} --verbose
    - name: Run tests
@@ -38,7 +38,7 @@ cmake-build-release/
 .history/

 # Visual Studio artifacts
-/.vs/
+/VS/

 # C/C++ build outputs
 .build/
@@ -106,4 +106,4 @@ objs
 !.vscode/extensions.json

 # clangd
-.cache
+.cache
@@ -3,9 +3,6 @@
        {"column": 95 },
        {"column": 120 }
    ],
-    "cmake.configureArgs": [
-        "-DSIMDJSON_DEVELOPER_MODE=ON"
-    ],
    "files.trimTrailingWhitespace": true,
    "files.associations": {
        ".clangd": "yaml",
@@ -112,23 +109,11 @@
        "numbers": "cpp",
        "semaphore": "cpp",
        "stop_token": "cpp",
-        "cfenv": "cpp",
-        "format": "cpp",
-        "xlocmes": "cpp",
-        "xlocmon": "cpp",
-        "xlocnum": "cpp",
-        "xloctime": "cpp",
-        "xutility": "cpp",
-        "coroutine": "cpp",
-        "xfacet": "cpp",
-        "xhash": "cpp",
-        "xiosbase": "cpp",
-        "xlocale": "cpp",
-        "xlocbuf": "cpp",
-        "xlocinfo": "cpp",
-        "xmemory": "cpp",
-        "xstring": "cpp",
-        "xtr1common": "cpp",
-        "xtree": "cpp"
+        "cfenv": "cpp"
+    },
+    "cmake.configureSettings": {
+        "CMAKE_EXPORT_COMPILE_COMMANDS": "YES",
+        "SIMDJSON_DEVELOPER_MODE": "ON",
+        "SIMDJSON_SINGLEHEADER": "OFF"
    }
 }
@@ -1,56 +0,0 @@
-# AI Usage Policy
-
-Contributors can use whatever tools they would like to
-craft their contributions, but there must be a **human in the loop**.
-**Contributors must read and review all LLM-generated code or text before they
-ask other project members to review it.** The contributor is always the author
-and is fully accountable for their contributions. Contributors should be
-sufficiently confident that the contribution is high enough quality that asking
-for a review is a good use of scarce maintainer time, and they should be **able
-to answer questions about their work** during review.
-
-We expect that new contributors will be less confident in their contributions,
-and our guidance to them is to **start with small contributions** that they can
-fully understand to build confidence. We aspire to be a welcoming community
-that helps new contributors grow their expertise, but learning involves taking
-small steps, getting feedback, and iterating. Passing maintainer feedback to an
-LLM doesn't help anyone grow, and does not sustain our community.
-
-This policy includes, but is not limited to, the following kinds of
-contributions:
-
- Code, usually in the form of a pull request
- Issues or security vulnerabilities
- Comments and feedback on pull requests
-
-## Extractive Contributions
-
-The reason for our "human-in-the-loop" contribution policy is that processing
-patches, PRs, RFCs, and comments is not free -- it takes a lot of
-maintainer time and energy to review those contributions! Sending the
-unreviewed output of an LLM to open source project maintainers *extracts* work
-from them in the form of design and code review, so we call this kind of
-contribution an "extractive contribution".
-
-## Transparency
-
-For contributions involving significant AI assistance, we encourage you to disclose
-its use and explain your process. If a submission appears to rely heavily on AI
-without disclosure, we may doubt that the **human-in-the-loop** requirement has
-been met. Please show awareness of your use of AI.
-
-## Copyright
-
-Artificial intelligence systems raise many questions around copyright that have
-yet to be answered. Our policy on AI tools is similar to our copyright policy:
-Contributors are responsible for ensuring that they have the right to
-contribute code under the terms of our license, typically meaning that either
-they, their employer, or their collaborators hold the copyright. Using AI tools
-to regenerate copyrighted material does not remove the copyright, and
-contributors are responsible for ensuring that such material does not appear in
-their contributions. Contributions found to violate this policy will be removed
-just like any other offending contribution.
-
-## Reference
-
- [LLVM AI Tool Use Policy](https://discourse.llvm.org/t/rfc-llvm-ai-tool-policy-human-in-the-loop/89159)
@@ -1,18 +1,9 @@
-cmake_minimum_required(VERSION 3.24)
-
-# Build performance optimizations
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL "Export compile commands for faster IDE integration")
-set_property(GLOBAL PROPERTY USE_FOLDERS ON)
-
-# Enable parallel compilation on MSVC
-if(MSVC)
-  add_compile_options(/MP)
-endif()
+cmake_minimum_required(VERSION 3.14)

 project(
    simdjson
    # The version number is modified by tools/release.py
-    VERSION 4.4.2
+    VERSION 3.10.1
    DESCRIPTION "Parsing gigabytes of JSON per second"
    HOMEPAGE_URL "https://simdjson.org/"
    LANGUAGES CXX C
@@ -29,8 +20,8 @@ string(
 # ---- Options, variables ----

 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "31.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "31" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_VERSION "23.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "23" CACHE STRING "simdjson library soversion")

 option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson (only makes sense if BUILD_SHARED_LIBS=ON)" OFF)
 if(SIMDJSON_BUILD_STATIC_LIB AND NOT BUILD_SHARED_LIBS)
@@ -52,20 +43,6 @@ if(SIMDJSON_DISABLE_DEPRECATED_API)
  )
 endif()

-if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.25.0")
-    option(SIMDJSON_STATIC_REFLECTION "Enables static reflection (experimental), requires C++26" OFF)
-else()
-    set(SIMDJSON_STATIC_REFLECTION OFF CACHE BOOL "Enables static reflection (experimental)" FORCE)
-    message(WARNING "SIMDJSON_STATIC_REFLECTION is disabled because your CMake version is below 3.25")
-endif()
-
-if(SIMDJSON_STATIC_REFLECTION)
-  simdjson_add_props(
-      target_compile_definitions PUBLIC
-      SIMDJSON_STATIC_REFLECTION=1
-  )
-endif()
-
 option(SIMDJSON_DEVELOPMENT_CHECKS "Enable development-time aids, such as \
 checks for incorrect API usage. Enabled by default in DEBUG." OFF)
 if(SIMDJSON_DEVELOPMENT_CHECKS)
@@ -92,36 +69,10 @@ add_library(simdjson ${SIMDJSON_SOURCES})
 add_library(simdjson::simdjson ALIAS simdjson)
 set(SIMDJSON_LIBRARIES simdjson)

-# Enable precompiled headers for faster builds
-if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")
-  target_precompile_headers(simdjson PRIVATE
-    <algorithm>
-    <array>
-    <atomic>
-    <bit>
-    <cassert>
-    <cctype>
-    <cerrno>
-    <cstddef>
-    <cstdint>
-    <cstdlib>
-    <cstring>
-    <memory>
-    <string>
-    <utility>
-    <vector>
-  )
-endif()
-
 if(SIMDJSON_BUILD_STATIC_LIB)
  add_library(simdjson_static STATIC ${SIMDJSON_SOURCES})
  add_library(simdjson::simdjson_static ALIAS simdjson_static)
  list(APPEND SIMDJSON_LIBRARIES simdjson_static)
-
-  # Reuse precompiled headers for static library
-  if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")
-    target_precompile_headers(simdjson_static REUSE_FROM simdjson)
-  endif()
 endif()

 set_target_properties(
@@ -133,7 +84,7 @@ set_target_properties(
 )

 # FIXME: Use proper CMake integration for exports
-if(WIN32 AND BUILD_SHARED_LIBS)
+if(MSVC AND BUILD_SHARED_LIBS)
  target_compile_definitions(
      simdjson
      PRIVATE SIMDJSON_BUILDING_WINDOWS_DYNAMIC_LIBRARY=1
@@ -147,24 +98,7 @@ simdjson_add_props(
    PRIVATE "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>"
 )

-# Optimize linker settings for faster builds
-if(MSVC)
-  target_link_options(simdjson PRIVATE /INCREMENTAL)
-  if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-    target_link_options(simdjson PRIVATE /DEBUG:FASTLINK)
-  endif()
-endif()
-
-if(SIMDJSON_STATIC_REFLECTION)
-  # We would like to require C++26, but no compiler supports that!
-  # This is a hack:
-  simdjson_add_props(
-      target_compile_options PUBLIC
-      -freflection -fexpansion-statements -stdlib=libc++ -std=c++26
-  )
-else()
-  simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
-endif()
+simdjson_add_props(target_compile_features PUBLIC cxx_std_11)

 # workaround for GNU GCC poor AVX load/store code generation
 if(
@@ -177,11 +111,23 @@ if(
  )
 endif()

-option(SIMDJSON_MINUS_ZERO_AS_FLOAT "Treat -0 as a floating-point value" OFF)
-
-if(SIMDJSON_MINUS_ZERO_AS_FLOAT)
-  simdjson_add_props(target_compile_definitions PRIVATE SIMDJSON_MINUS_ZERO_AS_FLOAT=1)
-endif(SIMDJSON_MINUS_ZERO_AS_FLOAT)
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(loongarch64)$")
+    option(SIMDJSON_PREFER_LSX "Prefer LoongArch SX" ON)
+    include(CheckCXXCompilerFlag)
+    check_cxx_compiler_flag(-mlasx COMPILER_SUPPORTS_LASX)
+    check_cxx_compiler_flag(-mlsx COMPILER_SUPPORTS_LSX)
+    if(COMPILER_SUPPORTS_LASX AND NOT SIMDJSON_PREFER_LSX)
+        simdjson_add_props(
+            target_compile_options PRIVATE
+            -mlasx
+        )
+    elseif(COMPILER_SUPPORTS_LSX)
+        simdjson_add_props(
+            target_compile_options PRIVATE
+            -mlsx
+        )
+    endif()
+endif()

 # GCC and Clang have horrendous Debug builds when using SIMD.
 # A common fix is to use '-Og' instead.
@@ -196,12 +142,7 @@ if(
      target_compile_options PRIVATE
      $<$<CONFIG:DEBUG>:-Og>
  )
-  # We still want to enable development checks in Debug mode
-  simdjson_add_props(
-      target_compile_definitions PUBLIC
-      SIMDJSON_DEVELOPMENT_CHECKS
-  )
-  endif()
+endif()

 if(SIMDJSON_ENABLE_THREADS)
  find_package(Threads REQUIRED)
@@ -346,7 +287,6 @@ enable_testing()
 add_custom_target(all_tests)

 add_subdirectory(windows)
-include(cmake/CPM.cmake)
 add_subdirectory(dependencies) ## This needs to be before tools because of cxxopts
 add_subdirectory(tools)  ## This needs to be before tests because of cxxopts

@@ -92,7 +92,7 @@ We welcome contributions from women and less represented groups. If you need hel

 Consider the following points when engaging with the project:

- We discourage arguments from authority: ideas are discussed on their own merits and not based on who stated it.
+- We discourage arguments from authority: ideas are discusssed on their own merits and not based on who stated it.
 - Be mindful that what you may view as an aggression is maybe merely a difference of opinion or a misunderstanding.
 - Be mindful that a collection of small aggressions, even if mild in isolation, can become harmful.

@@ -101,10 +101,3 @@ Getting Started Hacking

 An overview of simdjson's directory structure, with pointers to architecture and design
 considerations and other helpful notes, can be found at [HACKING.md](HACKING.md).
-
-
-
-AI Usage Policy
---------------
-
-Please also review our [AI Usage Policy](AI_USAGE_POLICY.md).
@@ -38,7 +38,7 @@ PROJECT_NAME           = simdjson
 # could be handy for archiving the generated documentation or if some version
 # control system is used.

-PROJECT_NUMBER         = "4.4.2"
+PROJECT_NUMBER         = "3.10.1"

 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -20,54 +20,13 @@ If you plan to contribute to simdjson, please read our [CONTRIBUTING](https://gi
 Build Quickstart
 ------------------------------

-For non-Windows system,
-
 ```bash
-cmake -B -D SIMDJSON_DEVELOPER_MODE=ON ..
-cmake --build build
-ctest --test-dir build
+mkdir build
+cd build
+cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
+cmake --build .
 ```

-It is similar for Visual Studio users, please see the CMake or Visual Studio documentation.
-
-By default the library is built in Release mode.
-
-
-Assertions and development checks
------------------------------
-
-We do not use conventional `assert` in simdjson. Instead we use the macro
-`SIMDJSON_ASSUME`:
-
-```cpp
-SIMDJSON_ASSUME(something_that_is_true());
-```
-
-Sometimes, you need to do a bit more work that a simple check.
-The `SIMDJSON_DEVELOPMENT_CHECKS` macro is true only in Debug mode unless manually set.
-It is acceptable to add checks that you would not do in Release mode as long as
-they are guarded:
-
-```cpp
-#if SIMDJSON_DEVELOPMENT_CHECKS
-// do sanity checks here
-```
-
-
-Working with sanitizers
------------------------------
-
-The simdjson library must be memory-safe. We cannot allow buffer overruns.
-During development, if you system supports it, we recommend configuring
-the project with `-D SIMDJSON_SANITIZE=ON`.
-
-```bash
-cmake -B -D SIMDJSON_SANITIZE=ON -D SIMDJSON_DEVELOPER_MODE=ON ..
-cmake --build build
-ctest --test-dir build
-```
-
-
 Design notes
 ------------------------------

@@ -110,24 +69,6 @@ workflows used by simdjson.
 Directory Structure and Source
 ------------------------------

-Before diving into the directory structure, here are key concepts used in the codebase:
-
- **Amalgamated File**: A file that is conditionally included in the amalgamation process. These are wrapped in `#ifndef SIMDJSON_CONDITIONAL_INCLUDE` blocks and are included based on the target implementation (e.g., ARM64, x86). They include implementation-specific files (e.g., `arm64.h`) and generic files (e.g., under `generic/`). Amalgamated files have associated dependency files (`dependencies.h`) to track includes.
-
- **Amalgamator File**: A file that orchestrates the inclusion of amalgamated files. Examples: `arm64.h`, `arm64/implementation.h`, `generic/amalgamated.h`. These are not themselves amalgamated but control conditional inclusions.
-
- **Free Dependency File**: A top-level header that is always included unconditionally. These do not have dependency files and represent the public API (e.g., main headers).
-
- **Implementation-Specific File**: A file tied to a specific CPU architecture or instruction set (e.g., `arm64/`, `haswell/`). These must be amalgamated.
-
- **Generic File**: A shared file (under `generic/` or `simdjson/generic/`) that contains common code included once per implementation.
-
- **Builtin File**: Special files under `simdjson/builtin/` that handle the builtin implementation, a fallback/default implementation used when no optimized implementation is available.
-
- **Conditional Include Block**: A section wrapped in `#ifndef SIMDJSON_CONDITIONAL_INCLUDE` for editor-only or implementation-specific content.
-
-The script `singleheader/amalgation_helper.py` will generate an HTML report which you can use to visualize the status of each file.
-
 simdjson's source structure, from the top level, looks like this:

 * **CMakeLists.txt:** The main build system.
@@ -151,12 +92,6 @@ simdjson's source structure, from the top level, looks like this:
    * simdjson/generic/ondemand/*.h: individual On-Demand classes, generically written.
      * simdjson/generic/ondemand/dependencies.h: dependencies on common, non-implementation-specific simdjson classes. This will be included before including amalgamated.h.
      * simdjson/generic/ondemand/amalgamated.h: all generic ondemand classes for an implementation.
-  * simdjson/builder.h: the `simdjson::builder` namespace. Includes all public builder classes.
-    * simdjson/builtin/builder.h: the `simdjson::builtin::builder` namespace.
-    * simdjson/arm64|fallback|haswell|icelake|ppc64|westmere/builder.h: the `simdjson::<implementation>::builder` namespace. Builder compiled for the specific implementation.
-    * simdjson/generic/builder/*.h: individual Builder classes, generically written.
-      * simdjson/generic/builder/dependencies.h: dependencies on common, non-implementation-specific simdjson classes. This will be included before including amalgamated.h.
-      * simdjson/generic/builder/amalgamated.h: all generic builder classes for an implementation.
 * **src:** The source files for non-inlined functionality (e.g. the architecture-specific parser
  implementations).
  * simdjson.cpp: A "main source" that includes all implementation files from src/. This is
@@ -168,10 +103,12 @@ simdjson's source structure, from the top level, looks like this:
    * generic/stage2/*.h: `simdjson::<implementation>::stage2` namespace. Generic implementation of the tape creator, which consumes the index from stage 1 and actually parses numbers and string and such. Used for the DOM interface.

 Other important files and directories:
+* **.drone.yml:** Definitions for Drone CI.
+* **.appveyor.yml:** Definitions for Appveyor CI (Windows).
+* **.circleci:** Definitions for Circle CI.
 * **.github/workflows:** Definitions for GitHub Actions (CI).
 * **singleheader:** Contains generated `simdjson.h` and `simdjson.cpp` that we release. The files `singleheader/simdjson.h` and `singleheader/simdjson.cpp` should never be edited by hand.
-* **singleheader/amalgamate.py:** Generates `singleheader/simdjson.h` and `singleheader/simdjson.cpp` for release (python script). If you add a new implementation (e.g., rvv), you need to edit this file (IMPLEMENTATIONS).
-* **singleheader/amalgation_helper.py:** Generates and `amalgamation_report.html` that helps you understand the status of each file.
+* **singleheader/amalgamate.py:** Generates `singleheader/simdjson.h` and `singleheader/simdjson.cpp` for release (python script).
 * **benchmark:** This is where we do benchmarking. Benchmarking is core to every change we make; the
  cardinal rule is don't regress performance without knowing exactly why, and what you're trading
  for it. Many of our benchmarks are microbenchmarks. We are effectively doing controlled scientific experiments for the purpose of understanding what affects our performance. So we simplify as much as possible. We try to avoid irrelevant factors such as page faults, interrupts, unnecessary system calls. We recommend checking the performance as follows:
@@ -186,7 +186,7 @@
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

-   Copyright 2018-2025 The simdjson authors
+   Copyright 2018-2023 The simdjson authors

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -1,18 +0,0 @@
-Copyright 2018-2025 The simdjson authors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -1,13 +1,14 @@
-[![][license img]][license] [![][licensemit img]][licensemit]

+[![Ubuntu 20.04 CI](https://github.com/simdjson/simdjson/workflows/Ubuntu%2020.04%20CI%20(GCC%209)/badge.svg)](https://simdjson.org/plots.html)
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/simdjson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:simdjson)
+[![][license img]][license]

 [![Doxygen Documentation](https://img.shields.io/badge/docs-doxygen-green.svg)](https://simdjson.github.io/simdjson/)

 simdjson : Parsing gigabytes of JSON per second
 ===============================================

-<img src="images/official_logo/logo_noir/SVG/logo_simdjson_noir.svg" width="40%" style="float: right">
-
+<img src="images/logo.png" width="10%" style="float: right">
 JSON is everywhere on the Internet. Servers spend a *lot* of time parsing it. We need a fresh
 approach. The simdjson library uses commonly available SIMD instructions and microparallel algorithms
 to parse JSON 4x  faster than RapidJSON and 25x faster than JSON for Modern C++.
@@ -30,7 +31,6 @@ Table of Contents
 * [Documentation](#documentation)
 * [Godbolt](#godbolt)
 * [Performance results](#performance-results)
-* [Packages](#packages)
 * [Bindings and Ports of simdjson](#bindings-and-ports-of-simdjson)
 * [About simdjson](#about-simdjson)
 * [Funding](#funding)
@@ -61,18 +61,9 @@ Real-world usage
 - [ada-url](https://github.com/ada-url/ada)
 - [fastgron](https://github.com/adamritter/fastgron)
 - [WasmEdge](https://wasmedge.org)
- [RonDB](https://github.com/logicalclocks/rondb)
- [GreptimeDB](https://github.com/GreptimeTeam/greptimedb)
- [mamba](https://github.com/mamba-org/mamba)
- [Ladybird Browser](https://ladybird.org)
- [SereneDB](https://github.com/serenedb/serenedb)
-

 If you are planning to use simdjson in a product, please work from one of our releases.

-
-
-
 Quick Start
 -----------

@@ -89,7 +80,7 @@ The simdjson library is easily consumable with a single .h and .cpp file.
   ```
 2. Create `quickstart.cpp`:

-```cpp
+```c++
 #include <iostream>
 #include "simdjson.h"
 using namespace simdjson;
@@ -114,19 +105,15 @@ Documentation
 Usage documentation is available:

 * [Basics](doc/basics.md) is an overview of how to use simdjson and its APIs.
-* [Builder](doc/builder.md) is an overview of how to efficiently write JSON strings using simdjson.
 * [Performance](doc/performance.md) shows some more advanced scenarios and how to tune for them.
 * [Implementation Selection](doc/implementation-selection.md) describes runtime CPU detection and
  how you can work with it.
 * [API](https://simdjson.github.io/simdjson/) contains the automatically generated API documentation.
-* [Compile-Time Parsing](doc/compile_time.md) presents our compile-time parsing function (C++26 only).
-

 Godbolt
 -------------

 Some users may want to browse code along with the compiled assembly. You want to check out the following lists of examples:
-* [C++26 reflection example](https://godbolt.org/z/K3Px64TqK)
 * [simdjson examples with errors handled through exceptions](https://godbolt.org/z/7G5qE4sr9)
 * [simdjson examples with errors without exceptions](https://godbolt.org/z/e9dWb9E4v)

@@ -156,9 +143,6 @@ speed for [synthetic files over various sizes generated with a script](https://g
 For NDJSON files, we can exceed 3 GB/s with [our  multithreaded parsing functions](https://github.com/simdjson/simdjson/blob/master/doc/parse_many.md).


-Packages
------------------------------
-[![Packaging status](https://repology.org/badge/vertical-allrepos/simdjson.svg)](https://repology.org/project/simdjson/versions)


 Bindings and Ports of simdjson
@@ -183,13 +167,11 @@ We distinguish between "bindings" (which just wrap the C++ code) and a port to a
 - [simdjsone](https://github.com/saleyn/simdjsone): erlang bindings.
 - [lua-simdjson](https://github.com/FourierTransformer/lua-simdjson): lua bindings.
 - [hermes-json](https://hackage.haskell.org/package/hermes-json): haskell bindings.
- [zimdjson](https://github.com/EzequielRamis/zimdjson): Zig port.
- [simdjzon](https://github.com/travisstaloch/simdjzon): Zig port.
+- [simdjzon](https://github.com/travisstaloch/simdjzon): zig port.
 - [JSON-Simd](https://github.com/rawleyfowler/JSON-simd): Raku bindings.
 - [JSON::SIMD](https://metacpan.org/pod/JSON::SIMD): Perl bindings; fully-featured JSON module that uses simdjson for decoding.
 - [gemmaJSON](https://github.com/sainttttt/gemmaJSON): Nim JSON parser based on simdjson bindings.
 - [simdjson-java](https://github.com/simdjson/simdjson-java): Java port.
- [mruby-fast-json](https://github.com/Asmod4n/mruby-fast-json): mruby binding with high API coverage.

 About simdjson
 --------------
@@ -212,31 +194,10 @@ We have an in-depth paper focused on the UTF-8 validation:

 We also have an informal [blog post providing some background and context](https://branchfree.org/2019/02/25/paper-parsing-gigabytes-of-json-per-second/).

-For the video inclined, we had a talk at QCon San Francisco 2019<br />
+For the video inclined, <br />
 [![simdjson at QCon San Francisco 2019](http://img.youtube.com/vi/wlvKAT7SZIQ/0.jpg)](http://www.youtube.com/watch?v=wlvKAT7SZIQ)<br />
 (It was the best voted talk, we're kinda proud of it.)

-We also had a CppCon 2025 talk. We show how C++26 reflection allows for one-line serialization (to_json(player)) or deserialization—without invasive macros or manual mapping—using nothing but the C++ standard library. Whether you’re a performance junkie or simply interested in the roadmap for the next decade of C++ development, watch our full talk!
-
-[![simdjson at CppCon 2025](http://img.youtube.com/vi/Mcgk3CxHYMs/0.jpg)](http://www.youtube.com/watch?v=Mcgk3CxHYMs)<br />
-
-
-
-Citing this work
-----------------
-
-If you use simdjson in published research, please cite the software library. A suitable BibTeX entry is:
-
-```bibtex
-@misc{simdjson,
-  title={{The simdjson library: Parsing Gigabytes of JSON per Second}},
-  author={Daniel Lemire and Geoff Langdale and John Keiser and Paul Dreik and Francisco Thiesen and others},
-  year={2019},
-  howpublished={Software library},
-  note={https://github.com/simdjson/simdjson}
-}
-```
-
 Funding
 -------

@@ -246,28 +207,16 @@ RGPIN-2017-03910 and RGPIN-2024-03787.
 [license]: LICENSE
 [license img]: https://img.shields.io/badge/License-Apache%202-blue.svg

-
-[licensemit]: LICENSE-MIT
-[licensemit img]: https://img.shields.io/badge/License-MIT-blue.svg
-
-
 Contributing to simdjson
 ------------------------

 Head over to [CONTRIBUTING.md](CONTRIBUTING.md) for information on contributing to simdjson, and
 [HACKING.md](HACKING.md) for information on source, building, and architecture/design.

-
-Stars
------
-
-[![Star History Chart](https://api.star-history.com/svg?repos=simdjson/simdjson&type=Date)](https://www.star-history.com/#simdjson/simdjson&Date)
-
-
 License
 -------

-This code is made available under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html) as well as under the MIT License. As a user, you can pick the license you prefer.
+This code is made available under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html).

 Under Windows, we build some tools using the windows/dirent_portable.h file (which is outside our library code): it is under the liberal (business-friendly) MIT license.

@@ -4,9 +4,6 @@ add_subdirectory(dom)
 include_directories( . linux )
 link_libraries(simdjson-windows-headers test-data)
 link_libraries(simdjson)
-if(SIMDJSON_STATIC_REFLECTION)
-  add_compile_definitions(SIMDJSON_STATIC_REFLECTION=1)
-endif(SIMDJSON_STATIC_REFLECTION)

 add_executable(benchfeatures benchfeatures.cpp)
 add_executable(get_corpus_benchmark get_corpus_benchmark.cpp)
@@ -35,16 +32,3 @@ if (TARGET benchmark::benchmark)
  endif()
 endif()

-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-std=c++20" SIMDJSON_COMPILER_SUPPORTS_CXX20)
-if(SIMDJSON_STATIC_REFLECTION)
-  add_subdirectory(static_reflect)
-else()
-  if(SIMDJSON_EXCEPTIONS AND SIMDJSON_COMPILER_SUPPORTS_CXX20)
-    add_subdirectory(from)
-    add_subdirectory(car_builder)
-  endif()
-endif(SIMDJSON_STATIC_REFLECTION)
-
-
@@ -1,46 +0,0 @@
-# Accessor Performance Benchmarks (C++26)
-
-These benchmarks compare the performance of runtime vs compile-time JSON accessors.
-For the comparison to be meaningful, you must build simdjson with support for
-C++26 reflexion. See the `p2996` repository in the main project directory.
-
-## Files
-
- `accessor_benchmark.h` - Common benchmark framework and test data
- `runtime_accessors.h` - Runtime `at_path()` benchmarks
- `compile_time_accessors.h` - Compile-time `at_path_compiled()` benchmarks (requires C++26 reflection)
-
-## Benchmarks
-
-Each benchmark measures parsing + single field access:
-
-1. **accessor_simple** - Simple field: `.name`
-2. **accessor_nested** - Nested field: `.address.city`
-3. **accessor_deep** - Deep nested field: `.address.coordinates.lat`
-
-## Building (Linux/macOS)
-
-```bash
-cmake -B build -D SIMDJSON_STATIC_REFLECTION=ON -DSIMDJSON_DEVELOPER_MODE=ON
-cmake --build build --target=bench_ondemand
-```
-
-The `SIMDJSON_STATIC_REFLECTION` will be made unnecessary once mainstream compilers
-begin supporting C++26 sufficiently well.
-
-## Running (Linux/macOS)
-
-
-```bash
-# Run all accessor benchmarks
-./build/bench_ondemand --benchmark_filter="accessor"
-```
-
-## Results
-
-We find that compile-time accessors show performance improvements that scale with path depth:
- Simple fields: ~1.2x faster
- Nested fields: ~1.5x faster
- Deep nested fields: ~1.8x faster
-
-The speedup comes from eliminating runtime path parsing and conversion overhead.
@@ -1,132 +0,0 @@
-#pragma once
-
-#include "json_benchmark/file_runner.h"
-#include <string>
-
-namespace accessor_performance {
-
-using namespace json_benchmark;
-
-// Test JSON for accessor benchmarks
-static const char* TEST_JSON = R"({
-  "name": "Alice",
-  "age": 30,
-  "email": "alice@example.com",
-  "address": {
-    "street": "123 Main St",
-    "city": "Boston",
-    "state": "MA",
-    "zip": 12345,
-    "coordinates": {
-      "lat": 42.3601,
-      "lon": -71.0589
-    }
-  },
-  "scores": [95, 87, 92, 88, 91],
-  "preferences": {
-    "theme": "dark",
-    "notifications": {
-      "email": true,
-      "push": false,
-      "sms": true
-    }
-  }
-})";
-
-// Struct definitions for compile-time validation
-#if SIMDJSON_STATIC_REFLECTION
-struct Coordinates {
-  double lat;
-  double lon;
-};
-
-struct Address {
-  std::string street;
-  std::string city;
-  std::string state;
-  int64_t zip;
-  Coordinates coordinates;
-};
-
-struct Notifications {
-  bool email;
-  bool push;
-  bool sms;
-};
-
-struct Preferences {
-  std::string theme;
-  Notifications notifications;
-};
-
-struct TestData {
-  std::string name;
-  int64_t age;
-  std::string email;
-  Address address;
-  std::vector<int64_t> scores;
-  Preferences preferences;
-};
-#endif // SIMDJSON_STATIC_REFLECTION
-
-// Single-access benchmark runner: measures ONE field access per iteration
-template<typename I>
-struct single_access_runner : public file_runner<I> {
-  std::string result_string;
-  int64_t result_int{};
-  double result_double{};
-  bool result_bool{};
-
-  bool setup(benchmark::State &state) {
-    this->json = simdjson::padded_string(TEST_JSON, strlen(TEST_JSON));
-    state.SetBytesProcessed(int64_t(state.iterations()) * int64_t(this->json.size()));
-    return true;
-  }
-
-  bool before_run(benchmark::State &state) {
-    if (!file_runner<I>::before_run(state)) { return false; }
-    result_string.clear();
-    result_int = 0;
-    result_double = 0.0;
-    result_bool = false;
-    return true;
-  }
-
-  bool run(benchmark::State &) {
-    return this->implementation.run(this->json, result_string, result_int, result_double, result_bool);
-  }
-
-  template<typename R>
-  bool diff(benchmark::State &state, single_access_runner<R> &reference) {
-    if (result_string != reference.result_string ||
-        result_int != reference.result_int ||
-        result_double != reference.result_double ||
-        result_bool != reference.result_bool) {
-      std::cerr << "Accessor benchmark results differ!" << std::endl;
-      return false;
-    }
-    return true;
-  }
-
-  size_t items_per_iteration() {
-    return 1;
-  }
-};
-
-// Benchmark template definitions
-struct runtime_at_path_simple;
-template<typename I> simdjson_inline static void accessor_simple(benchmark::State &state) {
-  run_json_benchmark<single_access_runner<I>, single_access_runner<runtime_at_path_simple>>(state);
-}
-
-struct runtime_at_path_nested;
-template<typename I> simdjson_inline static void accessor_nested(benchmark::State &state) {
-  run_json_benchmark<single_access_runner<I>, single_access_runner<runtime_at_path_nested>>(state);
-}
-
-struct runtime_at_path_deep;
-template<typename I> simdjson_inline static void accessor_deep(benchmark::State &state) {
-  run_json_benchmark<single_access_runner<I>, single_access_runner<runtime_at_path_deep>>(state);
-}
-
-} // namespace accessor_performance
@@ -1,56 +0,0 @@
-#pragma once
-
-#if SIMDJSON_EXCEPTIONS && SIMDJSON_STATIC_REFLECTION
-
-#include "accessor_benchmark.h"
-
-namespace accessor_performance {
-
-using namespace simdjson;
-
-struct compile_time_at_path_simple {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
-    auto doc = parser.iterate(json);
-    std::string_view name;
-    auto r = ondemand::json_path::at_path_compiled<TestData, ".name">(doc);
-    if (r.get(name) != SUCCESS) return false;
-    result_str = name;
-    return true;
-  }
-};
-
-struct compile_time_at_path_nested {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
-    auto doc = parser.iterate(json);
-    std::string_view city;
-    auto r = ondemand::json_path::at_path_compiled<TestData, ".address.city">(doc);
-    if (r.get(city) != SUCCESS) return false;
-    result_str = city;
-    return true;
-  }
-};
-
-struct compile_time_at_path_deep {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string&, int64_t&, double &result_dbl, bool&) {
-    auto doc = parser.iterate(json);
-    double lat;
-    auto r = ondemand::json_path::at_path_compiled<TestData, ".address.coordinates.lat">(doc);
-    if (r.get(lat) != SUCCESS) return false;
-    result_dbl = lat;
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(accessor_simple, compile_time_at_path_simple)->UseManualTime();
-BENCHMARK_TEMPLATE(accessor_nested, compile_time_at_path_nested)->UseManualTime();
-BENCHMARK_TEMPLATE(accessor_deep, compile_time_at_path_deep)->UseManualTime();
-
-} // namespace accessor_performance
-
-#endif // SIMDJSON_EXCEPTIONS && SIMDJSON_STATIC_REFLECTION
@@ -1,53 +0,0 @@
-#pragma once
-
-#if SIMDJSON_EXCEPTIONS
-
-#include "accessor_benchmark.h"
-
-namespace accessor_performance {
-
-using namespace simdjson;
-
-struct runtime_at_path_simple {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
-    auto doc = parser.iterate(json);
-    std::string_view name;
-    if (doc.at_path(".name").get(name) != SUCCESS) return false;
-    result_str = name;
-    return true;
-  }
-};
-
-struct runtime_at_path_nested {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
-    auto doc = parser.iterate(json);
-    std::string_view city;
-    if (doc.at_path(".address.city").get(city) != SUCCESS) return false;
-    result_str = city;
-    return true;
-  }
-};
-
-struct runtime_at_path_deep {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string&, int64_t&, double &result_dbl, bool&) {
-    auto doc = parser.iterate(json);
-    double lat;
-    if (doc.at_path(".address.coordinates.lat").get(lat) != SUCCESS) return false;
-    result_dbl = lat;
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(accessor_simple, runtime_at_path_simple)->UseManualTime();
-BENCHMARK_TEMPLATE(accessor_nested, runtime_at_path_nested)->UseManualTime();
-BENCHMARK_TEMPLATE(accessor_deep, runtime_at_path_deep)->UseManualTime();
-
-} // namespace accessor_performance
-
-#endif // SIMDJSON_EXCEPTIONS
@@ -245,7 +245,7 @@ static u32 (*kpc_get_counter_count)(u32 classes);

 /// Get counter accumulations.
 /// If `all_cpus` is true, the buffer count should not smaller than
-/// (cpu_count * counter_count). Otherwise, the buffer count should not smaller
+/// (cpu_count * counter_count). Otherwize, the buffer count should not smaller
 /// than (counter_count).
 /// @see kpc_get_counter_count(), kpc_cpu_count().
 /// @param all_cpus true for all CPUs, false for current cpu.
@@ -374,7 +374,7 @@ static int kperf_lightweight_pet_set(u32 enabled) {
 // These functions do not require root privileges.
 // -----------------------------------------------------------------------------

-// KPEP CPU architecture constants.
+// KPEP CPU archtecture constants.
 #define KPEP_ARCH_I386 0
 #define KPEP_ARCH_X86_64 1
 #define KPEP_ARCH_ARM 2
@@ -414,7 +414,7 @@ typedef struct kpep_db {
  usize fixed_counter_count;
  usize config_counter_count;
  usize power_counter_count;
-  u32 architecture; ///< see `KPEP CPU architecture constants` above.
+  u32 archtecture; ///< see `KPEP CPU archtecture constants` above.
  u32 fixed_counter_bits;
  u32 config_counter_bits;
  u32 power_counter_bits;
@@ -148,9 +148,4 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #include "large_amazon_cellphones/simdjson_dom.h"
 #include "large_amazon_cellphones/simdjson_ondemand.h"

-#include "accessor_performance/runtime_accessors.h"
-#if SIMDJSON_STATIC_REFLECTION
-#include "accessor_performance/compile_time_accessors.h"
-#endif
-
 BENCHMARK_MAIN();
@@ -1,618 +0,0 @@
-#!/bin/bash
-
-# JSON Parsing Compilation Benchmark: Reflection Usage vs Manual Parsing
-# Compares compilation times when ACTUALLY USING reflection for parsing vs manual parsing
-# This measures the compile-time cost of reflection-based automatic deserialization
-
-set -e
-
-echo "=== simdjson Reflection Usage Compilation Benchmark ==="
-echo "Measuring compilation impact of ACTUALLY USING reflection for parsing"
-echo "Starting at: $(date)"
-echo
-echo "╔════════════════════════════════════════════════════════════════════════════╗"
-echo "║                              METHODOLOGY                                   ║"
-echo "╠════════════════════════════════════════════════════════════════════════════╣"
-echo "║                                                                            ║"
-echo "║ FAIR COMPARISON STRATEGY:                                                  ║"
-echo "║ This benchmark compares two DIFFERENT approaches to parsing the same JSON: ║"
-echo "║                                                                            ║"
-echo "║ • MANUAL PARSING: Traditional simdjson with explicit .get() calls          ║"
-echo "║   - Uses doc[\"field\"].get(variable) for each field                         ║"
-echo "║   - No reflection involved                                                 ║"
-echo "║                                                                            ║"
-echo "║ • REFLECTION PARSING: Automatic deserialization with reflection            ║"
-echo "║   - Uses doc.get<MyStruct>() for automatic field mapping                   ║"
-echo "║   - Relies on compile-time reflection to generate parsing code             ║"
-echo "║                                                                            ║"
-echo "║ WHAT WE'RE MEASURING:                                                      ║"
-echo "║ • Compile-time cost of reflection-based automatic deserialization          ║"
-echo "║ • Template instantiation overhead for reflection parsing                   ║"
-echo "║ • Code generation complexity from using reflection features                ║"
-echo "║                                                                            ║"
-echo "║ TEST SCENARIOS:                                                            ║"
-echo "║                                                                            ║"
-echo "║ 1. SIMPLE STRUCT: Basic fields (string, int, bool)                         ║"
-echo "║    - Measures baseline reflection overhead                                 ║"
-echo "║                                                                            ║"
-echo "║ 2. NESTED STRUCT: Multiple levels of nested objects                        ║"
-echo "║    - Measures reflection complexity scaling                                ║"
-echo "║                                                                            ║"
-echo "║ 3. COMPLEX STRUCT: Arrays, optional fields, mixed types                    ║"
-echo "║    - Measures real-world reflection usage impact                           ║"
-echo "║                                                                            ║"
-echo "║ WHY THIS IS MEANINGFUL:                                                    ║"
-echo "║ • Shows actual cost of using reflection features                           ║"
-echo "║ • Measures compile-time code generation overhead                           ║"
-echo "║ • Helps developers understand reflection's compilation impact              ║"
-echo "║ • Compares equivalent functionality implemented two different ways         ║"
-echo "║                                                                            ║"
-echo "╚════════════════════════════════════════════════════════════════════════════╝"
-echo
-
-# Configuration
-ITERATIONS=10
-JOBS=4
-
-# ───────────────────────────── BOX-PRINT HELPER ────────────────────────────
-BOX_WIDTH=74                               # characters between the pipes
-print_box_line() {                         # usage: print_box_line "text"
-  printf "║ %-*s ║\n" "${BOX_WIDTH}" "$1"
-}
-
-# Function to test if a compiler supports reflection with debug output
-test_reflection_support() {
-    local compiler="$1"
-    echo "  → Testing compiler: $compiler"
-
-    if [ ! -x "$compiler" ] && ! command -v "$compiler" >/dev/null 2>&1; then
-        echo "  → Compiler not found or not executable"
-        return 1
-    fi
-
-    # Check compiler version first
-    echo "  → Compiler version: $("$compiler" --version 2>/dev/null | head -n1 || echo "version check failed")"
-
-    # Simple test: check if compiler accepts reflection flags
-    local test_file=$(mktemp /tmp/reflection_test_XXXXXX.cpp)
-    cat > "$test_file" << 'EOF'
-int main() {
-    return 0;
-}
-EOF
-
-    echo "  → Testing basic reflection flags..."
-    local test_exe=$(mktemp /tmp/reflection_test_XXXXXX)
-    local basic_result=$("$compiler" -freflection -fexpansion-statements -std=c++26 "$test_file" -o "$test_exe" 2>&1)
-    local basic_exit_code=$?
-
-    if [ $basic_exit_code -ne 0 ]; then
-        echo "  → Basic flags FAILED with exit code $basic_exit_code"
-        echo "  → Error output: $basic_result"
-        rm -f "$test_file" "$test_exe"
-        return 1
-    fi
-    echo "  → Basic flags: OK"
-    rm -f "$test_exe"
-
-    # Test reflection syntax
-    echo "  → Testing reflection syntax..."
-    cat > "$test_file" << 'EOF'
-struct Test {
-    int x;
-};
-
-int main() {
-    auto refl = ^^Test;
-    return 0;
-}
-EOF
-
-    local syntax_result=$("$compiler" -freflection -fexpansion-statements -std=c++26 "$test_file" -o "$test_exe" 2>&1)
-    local syntax_exit_code=$?
-
-    if [ $syntax_exit_code -eq 0 ]; then
-        echo "  → Reflection syntax: OK"
-        echo "  → ✓ REFLECTION SUPPORT CONFIRMED"
-        rm -f "$test_file" "$test_exe"
-        return 0
-    else
-        echo "  → Reflection syntax FAILED with exit code $syntax_exit_code"
-        echo "  → Error output: $syntax_result"
-        rm -f "$test_file" "$test_exe"
-        return 1
-    fi
-}
-
-# Find a compiler with reflection support
-echo "Searching for clang++ with reflection support..."
-
-REFLECTION_CXX=""
-REFLECTION_CC=""
-
-# List of potential clang++ locations to check
-POTENTIAL_COMPILERS=(
-    "/usr/local/bin/clang++"
-    "/opt/clang/bin/clang++"
-    "/usr/bin/clang++"
-    "clang++"
-)
-
-# If CXX is already set, test it first
-if [ -n "$CXX" ]; then
-    echo "Testing user-specified compiler: $CXX"
-    if test_reflection_support "$CXX"; then
-        REFLECTION_CXX="$CXX"
-        echo "✓ User-specified compiler supports reflection: $CXX"
-    else
-        echo "✗ User-specified compiler does not support reflection: $CXX"
-        echo "Will search for alternative..."
-    fi
-fi
-
-# If we don't have a working compiler yet, search for one
-if [ -z "$REFLECTION_CXX" ]; then
-    for compiler in "${POTENTIAL_COMPILERS[@]}"; do
-        echo "Testing: $compiler"
-        if test_reflection_support "$compiler"; then
-            REFLECTION_CXX="$compiler"
-            echo "✓ Found reflection-enabled compiler: $compiler"
-            break
-        else
-            echo "✗ No reflection support: $compiler"
-        fi
-    done
-fi
-
-# Check if we found a working compiler
-if [ -z "$REFLECTION_CXX" ]; then
-    echo
-    echo "╔════════════════════════════════════════════════════════════════════════════╗"
-    echo "║                                 ERROR                                      ║"
-    echo "╠════════════════════════════════════════════════════════════════════════════╣"
-    echo "║                                                                            ║"
-    echo "║ No clang++ compiler with reflection support found!                        ║"
-    echo "║                                                                            ║"
-    echo "║ This benchmark requires a compiler that supports C++26 reflection.        ║"
-    echo "║                                                                            ║"
-    echo "║ Options:                                                                   ║"
-    echo "║ 1. Use the Docker container: ./p2996/run_docker.sh                        ║"
-    echo "║ 2. Build clang with reflection from: https://github.com/bloomberg/clang-p2996 ║"
-    echo "║ 3. Set CXX environment variable to point to reflection-enabled clang++    ║"
-    echo "║                                                                            ║"
-    echo "║ Example: CXX=/path/to/reflection-clang++ ./benchmark_script.sh            ║"
-    echo "║                                                                            ║"
-    echo "╚════════════════════════════════════════════════════════════════════════════╝"
-    exit 1
-fi
-
-# Set the compilers
-export CXX="$REFLECTION_CXX"
-
-# Find corresponding C compiler
-if [ -n "$CC" ]; then
-    REFLECTION_CC="$CC"
-elif [ "$REFLECTION_CXX" = "/usr/local/bin/clang++" ]; then
-    REFLECTION_CC="/usr/local/bin/clang"
-elif [ "$REFLECTION_CXX" = "/opt/clang/bin/clang++" ]; then
-    REFLECTION_CC="/opt/clang/bin/clang"
-elif [ "$REFLECTION_CXX" = "/usr/bin/clang++" ]; then
-    REFLECTION_CC="/usr/bin/clang"
-else
-    REFLECTION_CC="clang"
-fi
-
-export CC="$REFLECTION_CC"
-
-echo
-echo "Using reflection-enabled compiler: $($CXX --version | head -n1)"
-echo "Using C compiler: $($CC --version | head -n1)"
-echo
-
-# Function to create manual parsing test
-create_manual_parsing_test() {
-    local test_name="$1"
-    local struct_complexity="$2"
-
-    cat > "${test_name}_manual.cpp" << 'EOF'
-#include <simdjson.h>
-#include <iostream>
-#include <string>
-#include <vector>
-#include <optional>
-
-// Test structures
-struct Person {
-    std::string name;
-    int age;
-    bool active;
-};
-
-struct Address {
-    std::string street;
-    std::string city;
-    int zipcode;
-};
-
-struct Employee {
-    Person person;
-    Address address;
-    std::vector<std::string> skills;
-    std::optional<std::string> department;
-    double salary;
-};
-
-// Manual parsing functions
-bool parse_person_manual(simdjson::ondemand::value& val, Person& person) {
-    auto obj = val.get_object();
-    if (obj.error()) return false;
-
-    for (auto field : obj) {
-        std::string_view key = field.unescaped_key();
-        if (key == "name") {
-            std::string_view name_val;
-            if (field.value().get(name_val)) return false;
-            person.name = name_val;
-        } else if (key == "age") {
-            if (field.value().get(person.age)) return false;
-        } else if (key == "active") {
-            if (field.value().get(person.active)) return false;
-        }
-    }
-    return true;
-}
-
-bool parse_address_manual(simdjson::ondemand::value& val, Address& address) {
-    auto obj = val.get_object();
-    if (obj.error()) return false;
-
-    for (auto field : obj) {
-        std::string_view key = field.unescaped_key();
-        if (key == "street") {
-            std::string_view street_val;
-            if (field.value().get(street_val)) return false;
-            address.street = street_val;
-        } else if (key == "city") {
-            std::string_view city_val;
-            if (field.value().get(city_val)) return false;
-            address.city = city_val;
-        } else if (key == "zipcode") {
-            if (field.value().get(address.zipcode)) return false;
-        }
-    }
-    return true;
-}
-
-bool parse_employee_manual(simdjson::ondemand::document& doc, Employee& employee) {
-    auto obj = doc.get_object();
-    if (obj.error()) return false;
-
-    for (auto field : obj) {
-        std::string_view key = field.unescaped_key();
-        if (key == "person") {
-            auto person_val = field.value();
-            if (!parse_person_manual(person_val, employee.person)) return false;
-        } else if (key == "address") {
-            auto addr_val = field.value();
-            if (!parse_address_manual(addr_val, employee.address)) return false;
-        } else if (key == "skills") {
-            auto skills_array = field.value().get_array();
-            if (skills_array.error()) return false;
-            for (auto skill : skills_array) {
-                std::string_view skill_val;
-                if (skill.get(skill_val)) return false;
-                employee.skills.emplace_back(skill_val);
-            }
-        } else if (key == "department") {
-            std::string_view dept_val;
-            if (!field.value().get(dept_val)) {
-                employee.department = dept_val;
-            }
-        } else if (key == "salary") {
-            if (field.value().get(employee.salary)) return false;
-        }
-    }
-    return true;
-}
-
-int main() {
-    simdjson::ondemand::parser parser;
-    std::string json_str = R"({
-        "person": {
-            "name": "John Doe",
-            "age": 30,
-            "active": true
-        },
-        "address": {
-            "street": "123 Main St",
-            "city": "Anytown",
-            "zipcode": 12345
-        },
-        "skills": ["C++", "JSON", "Programming"],
-        "department": "Engineering",
-        "salary": 85000.50
-    })";
-
-    simdjson::ondemand::document doc;
-    auto error = parser.iterate(simdjson::pad(json_str)).get(doc);
-    if (error) {
-        std::cerr << "Parse error" << std::endl;
-        return 1;
-    }
-
-    Employee employee;
-    if (!parse_employee_manual(doc, employee)) {
-        std::cerr << "Manual parsing failed" << std::endl;
-        return 1;
-    }
-
-    std::cout << "Manual parsing successful: " << employee.person.name
-              << ", age " << employee.person.age << std::endl;
-    return 0;
-}
-EOF
-}
-
-# Function to create reflection parsing test
-create_reflection_parsing_test() {
-    local test_name="$1"
-    local struct_complexity="$2"
-
-    cat > "${test_name}_reflection.cpp" << 'EOF'
-#include <simdjson.h>
-#include <iostream>
-#include <string>
-#include <vector>
-#include <optional>
-
-// Test structures (same as manual version)
-struct Person {
-    std::string name;
-    int age;
-    bool active;
-};
-
-struct Address {
-    std::string street;
-    std::string city;
-    int zipcode;
-};
-
-struct Employee {
-    Person person;
-    Address address;
-    std::vector<std::string> skills;
-    std::optional<std::string> department;
-    double salary;
-};
-
-int main() {
-    simdjson::ondemand::parser parser;
-    std::string json_str = R"({
-        "person": {
-            "name": "John Doe",
-            "age": 30,
-            "active": true
-        },
-        "address": {
-            "street": "123 Main St",
-            "city": "Anytown",
-            "zipcode": 12345
-        },
-        "skills": ["C++", "JSON", "Programming"],
-        "department": "Engineering",
-        "salary": 85000.50
-    })";
-
-    simdjson::ondemand::document doc;
-    auto error = parser.iterate(simdjson::pad(json_str)).get(doc);
-    if (error) {
-        std::cerr << "Parse error" << std::endl;
-        return 1;
-    }
-
-    // Use reflection-based automatic deserialization
-    Employee employee;
-    auto result = doc.get<Employee>();
-    if (result.error()) {
-        std::cerr << "Reflection parsing failed" << std::endl;
-        return 1;
-    }
-    employee = result.value();
-
-    std::cout << "Reflection parsing successful: " << employee.person.name
-              << ", age " << employee.person.age << std::endl;
-    return 0;
-}
-EOF
-}
-
-# Function to time compilation of parsing approach
-time_parsing_compilation() {
-    local description="$1"
-    local test_file="$2"
-    local use_reflection="$3"
-    local iteration="$4"
-
-    echo "[$iteration] $description"
-
-    # Clean build
-    rm -rf build_parsing_test
-    mkdir build_parsing_test
-    cd build_parsing_test
-
-    # Copy test file
-    cp "../$test_file" .
-
-    echo "  Configuring..."
-    if [ "$use_reflection" = "true" ]; then
-        cmake -DCMAKE_CXX_COMPILER="$CXX" \
-              -DSIMDJSON_DEVELOPER_MODE=ON \
-              -DSIMDJSON_STATIC_REFLECTION=ON \
-              -DBUILD_SHARED_LIBS=OFF \
-              ../.. >/dev/null 2>&1
-    else
-        cmake -DCMAKE_CXX_COMPILER="$CXX" \
-              -DSIMDJSON_DEVELOPER_MODE=ON \
-              -DSIMDJSON_STATIC_REFLECTION=OFF \
-              -DBUILD_SHARED_LIBS=OFF \
-              ../.. >/dev/null 2>&1
-    fi
-
-    echo "  Building simdjson..."
-    cmake --build . --target simdjson >/dev/null 2>&1
-
-    echo "  Compiling parsing test..."
-    # Time just the test compilation
-    start_time=$(date +%s.%N)
-
-    "$CXX" -std=c++17 -I../../include "$test_file" -L. -lsimdjson -o parsing_test >/dev/null 2>&1
-
-    end_time=$(date +%s.%N)
-
-    # Calculate time duration
-    time_taken=$(echo "$end_time $start_time" | awk '{printf "%.3f", $1 - $2}')
-    echo "  Completed in: ${time_taken}s"
-
-    cd ..
-    rm -rf build_parsing_test
-
-    echo "$time_taken"
-}
-
-# Create test files
-echo "Creating test files..."
-create_manual_parsing_test "complex" "complex"
-create_reflection_parsing_test "complex" "complex"
-
-# Arrays to store times
-times_manual=""
-times_reflection=""
-
-echo
-echo "=== MANUAL PARSING COMPILATION ==="
-echo "Testing traditional simdjson parsing with explicit .get() calls"
-echo
-
-for i in $(seq 1 $ITERATIONS); do
-    time_result=$(time_parsing_compilation "Compiling manual parsing test" "complex_manual.cpp" "false" "$i" | tail -n1)
-    times_manual="$times_manual $time_result"
-done
-
-echo
-echo "=== REFLECTION PARSING COMPILATION ==="
-echo "Testing automatic deserialization with doc.get<Struct>()"
-echo
-
-for i in $(seq 1 $ITERATIONS); do
-    time_result=$(time_parsing_compilation "Compiling reflection parsing test" "complex_reflection.cpp" "true" "$i" | tail -n1)
-    times_reflection="$times_reflection $time_result"
-done
-
-echo
-echo "╔════════════════════════════════════════════════════════════════════════════╗"
-echo "║           REFLECTION USAGE COMPILATION RESULTS                             ║"
-echo "╠════════════════════════════════════════════════════════════════════════════╣"
-echo "║                                                                            ║"
-echo "║ MANUAL PARSING (explicit .get() calls):                                    ║"
-count=1
-for t in $times_manual; do
-    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
-        line=$(printf "Run %2d: %7.3f seconds" "$count" "$t")
-        print_box_line "$line"
-        count=$((count + 1))
-    fi
-done
-echo "║                                                                            ║"
-echo "║ REFLECTION PARSING (automatic doc.get<Struct>()):                          ║"
-count=1
-for t in $times_reflection; do
-    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
-        line=$(printf "Run %2d: %7.3f seconds" "$count" "$t")
-        print_box_line "$line"
-        count=$((count + 1))
-    fi
-done
-echo "╚════════════════════════════════════════════════════════════════════════════╝"
-
-echo
-echo "╔════════════════════════════════════════════════════════════════════════════╗"
-echo "║                              ANALYSIS SUMMARY                              ║"
-echo "╠════════════════════════════════════════════════════════════════════════════╣"
-echo "║                                                                            ║"
-
-# Calculate averages and percentages - filter to only numeric values first
-manual_numbers=""
-reflection_numbers=""
-
-for t in $times_manual; do
-    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
-        manual_numbers="$manual_numbers $t"
-    fi
-done
-
-for t in $times_reflection; do
-    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
-        reflection_numbers="$reflection_numbers $t"
-    fi
-done
-
-if [ -n "$manual_numbers" ] && [ -n "$reflection_numbers" ]; then
-    manual_avg=$(echo "$manual_numbers" | awk '{sum=0; for(i=1;i<=NF;i++) sum+=$i; print sum/NF}')
-    reflection_avg=$(echo "$reflection_numbers" | awk '{sum=0; for(i=1;i<=NF;i++) sum+=$i; print sum/NF}')
-    overhead=$(echo "$reflection_avg $manual_avg" | awk '{printf "%.3f", $1 - $2}')
-
-    if [ $(echo "$manual_avg > 0" | awk '{print ($1 > 0)}') -eq 1 ]; then
-        percent=$(echo "$reflection_avg $manual_avg" | awk '{printf "%.1f", ($1 - $2) / $2 * 100}')
-    else
-        percent="0"
-    fi
-
-    print_box_line "MANUAL PARSING RESULTS:"
-    print_box_line "$(printf "Average compilation time: %.3fs" "$manual_avg")"
-    print_box_line ""
-    print_box_line "REFLECTION PARSING RESULTS:"
-    print_box_line "$(printf "Average compilation time: %.3fs" "$reflection_avg")"
-    print_box_line ""
-    print_box_line "REFLECTION OVERHEAD:"
-    print_box_line "$(printf "Additional time: %.3fs (%+.1f%%)" "$overhead" "$percent")"
-    print_box_line ""
-else
-    echo "║ ERROR: Could not extract valid timing data                                 ║"
-    echo "║ Manual times: $times_manual"
-    echo "║ Reflection times: $times_reflection"
-    echo "║                                                                            ║"
-fi
-
-echo "╠════════════════════════════════════════════════════════════════════════════╣"
-echo "║                              INTERPRETATION                                ║"
-echo "╠════════════════════════════════════════════════════════════════════════════╣"
-echo "║                                                                            ║"
-echo "║ WHAT THESE RESULTS SHOW:                                                   ║"
-echo "║                                                                            ║"
-echo "║ • COMPILE-TIME COST: How much longer reflection parsing takes to compile   ║"
-echo "║   - Higher % = more expensive template instantiation and codegen           ║"
-echo "║                                                                            ║"
-echo "║ • CODE GENERATION OVERHEAD: Reflection creates parsing code at compile     ║"
-echo "║   time, which requires more template processing than manual parsing        ║"
-echo "║                                                                            ║"
-echo "║ • DEVELOPER TRADE-OFF: Reflection provides automatic deserialization       ║"
-echo "║   but at the cost of increased compilation time                            ║"
-echo "║                                                                            ║"
-echo "║ EVALUATION:                                                                ║"
-echo "║ • Low overhead (0-20%): Reflection is compile-time efficient               ║"
-echo "║ • Medium overhead (20-50%): Noticeable but potentially acceptable          ║"
-echo "║ • High overhead (50%+): Significant compilation cost for reflection        ║"
-echo "║                                                                            ║"
-echo "║ REAL-WORLD IMPACT:                                                         ║"
-echo "║ • Small projects: Absolute time matters more than percentage               ║"
-echo "║ • Large projects: Percentage overhead compounds across many files          ║"
-echo "║ • CI/CD pipelines: Longer builds affect development velocity               ║"
-echo "║                                                                            ║"
-echo "╚════════════════════════════════════════════════════════════════════════════╝"
-
-# Clean up test files
-rm -f complex_manual.cpp complex_reflection.cpp
-
-echo
-echo "Completed at: $(date)"
@@ -1,14 +0,0 @@
-# Executable
-add_executable(benchmark_car_builder benchmark_car_builder.cpp)
-
-# Compile for C++20.
-target_compile_features(benchmark_car_builder PRIVATE cxx_std_20)
-
-# Check if -march=native is supported
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-march=native" SIMDJSON_SUPPORTS_MARCH_NATIVE)
-if(SIMDJSON_SUPPORTS_MARCH_NATIVE)
-  target_compile_options(benchmark_car_builder PRIVATE -march=native)
-endif()
-
-target_include_directories(benchmark_car_builder PRIVATE ${CMAKE_CURRENT_LIST_DIR}/..)
@@ -1,127 +0,0 @@
-#include "event_counter.h"
-#include <random>
-#include <vector>
-
-#include <simdjson.h>
-
-event_collector collector;
-
-struct Car {
-  std::string make;
-  std::string model;
-  int64_t year; // We deliberately do not include the tire pressure.
-};
-
-std::vector<Car> generate_random_cars(size_t count) {
-  static const std::vector<std::string> makes = {"Toyota", "Honda", "Ford",
-                                                 "BMW", "Mazda"};
-  static const std::vector<std::string> models = {"Camry", "Civic", "Focus",
-                                                  "320i", "3"};
-  static thread_local std::mt19937 rng{std::random_device{}()};
-  std::uniform_int_distribution<int> make_dist(0, makes.size() - 1);
-  std::uniform_int_distribution<int> model_dist(0, models.size() - 1);
-  std::uniform_int_distribution<int64_t> year_dist(2000, 2025);
-  std::uniform_real_distribution<double> pressure_dist(30.0, 45.0);
-
-  std::vector<Car> cars;
-  cars.reserve(count);
-  for (size_t i = 0; i < count; ++i) {
-    Car car;
-    car.make = makes[make_dist(rng)];
-    car.model = models[model_dist(rng)];
-    car.year = year_dist(rng);
-    cars.push_back(std::move(car));
-  }
-  return cars;
-}
-
-std::string_view serialize(simdjson::builder::string_builder &sb,
-                           const std::vector<Car> &cars) {
-  sb.clear();
-  sb.start_array();
-  for (const auto &car : cars) {
-    sb.start_object();
-    sb.append_key_value("make", car.make);
-    sb.append_comma();
-    sb.append_key_value("model", car.model);
-    sb.append_comma();
-    sb.append_key_value("year", car.year);
-    sb.end_object();
-  }
-  sb.end_array();
-  std::string_view result;
-  if (sb.view().get(result)) {
-    return ""; // unexpected (error)
-  }
-  return result;
-}
-
-double pretty_print(const std::string &name, size_t num_chars,
-                    std::pair<event_aggregate, size_t> result) {
-  const auto &agg = result.first;
-  size_t N = result.second;
-  num_chars *= N;
-  printf("%-40s : %8.2f ns %8.2f GB/s", name.c_str(),
-         agg.elapsed_ns() / num_chars, num_chars / agg.elapsed_ns());
-  if (collector.has_events()) {
-    printf(" %8.2f GHz %8.2f cycles/char %8.2f ins./char %8.2f i/c",
-           agg.cycles() / agg.elapsed_ns(), agg.cycles() / num_chars,
-           agg.instructions() / num_chars, agg.instructions() / agg.cycles());
-  }
-  printf("\n");
-  return num_chars / agg.elapsed_ns();
-}
-
-template <class function_type>
-std::pair<event_aggregate, size_t>
-bench(const function_type &&function, size_t min_repeat = 100,
-      size_t min_time_ns = 40'000'000, size_t max_repeat = 10000000) {
-  size_t N = min_repeat;
-  if (N == 0) {
-    N = 1;
-  }
-  event_aggregate warm_aggregate{};
-  for (size_t i = 0; i < N; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    function();
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    warm_aggregate << allocate_count;
-    if ((i + 1 == N) && (warm_aggregate.total_elapsed_ns() < min_time_ns) &&
-        (N < max_repeat)) {
-      N *= 10;
-    }
-  }
-  event_aggregate aggregate{};
-  for (size_t i = 0; i < 10; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    for (size_t i = 0; i < N; i++) {
-      function();
-    }
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    aggregate << allocate_count;
-  }
-  return {aggregate, N};
-}
-
-void run_benchmarks() {
-  std::vector<Car> source = generate_random_cars(100000);
-  simdjson::builder::string_builder sb;
-  size_t volume = serialize(sb, source).size();
-
-  pretty_print("string_builder", volume, bench([&source, &sb]() -> size_t {
-                 return serialize(sb, source).size();
-               }));
-}
-
-int main() {
-  for (size_t trial = 0; trial < 3; trial++) {
-    printf("Trial %zu:\n", trial + 1);
-    run_benchmarks();
-    printf("\n");
-  }
-  return EXIT_SUCCESS;
-}
@@ -44,10 +44,7 @@ struct yyjson_base {

 struct yyjson : yyjson_base {
  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
  }
 };
 BENCHMARK_TEMPLATE(distinct_user_id, yyjson)->UseManualTime();
@@ -55,15 +52,11 @@ BENCHMARK_TEMPLATE(distinct_user_id, yyjson)->UseManualTime();
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
  }
 };
 BENCHMARK_TEMPLATE(distinct_user_id, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace distinct_user_id

 #endif // SIMDJSON_COMPETITION_YYJSON
@@ -25,11 +25,12 @@ int main(int argc, char *argv[]) {
    exit(1);
  }
  const char *filename = argv[1];
-  simdjson::padded_string p;
-  if (simdjson::padded_string::load(filename).get(p)) {
+  auto v = simdjson::padded_string::load(filename);
+  if (v.error()) {
    std::cerr << "Could not load the file " << filename << std::endl;
    return EXIT_FAILURE;
  }
+  const simdjson::padded_string& p = v.value_unsafe();
  if (test_baseline) {
    std::wclog << "Baseline: Getline + normal parse... " << std::endl;
    std::cout << "Gigabytes/second\t"
@@ -122,7 +122,6 @@ struct event_aggregate {
  }

  double elapsed_sec() const { return total.elapsed_sec() / iterations; }
-  double total_elapsed_ns() const { return total.elapsed_ns(); }
  double elapsed_ns() const { return total.elapsed_ns() / iterations; }
  double cycles() const { return total.cycles() / iterations; }
  double instructions() const { return total.instructions() / iterations; }
@@ -13,7 +13,7 @@ struct nlohmann_json {
    auto root = nlohmann::json::parse(json.data(), json.data() + json.size());
    for (auto tweet : root["statuses"]) {
      if (tweet["id"] == find_id) {
-        result = to_string(tweet["text"]);
+        result = tweet["text"];
        return true;
      }
    }
@@ -36,26 +36,18 @@ struct yyjson_base {

 struct yyjson : yyjson_base {
  bool run(simdjson::padded_string &json, uint64_t find_id, std::string_view &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
-    bool b = yyjson_base::run(doc, find_id, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), find_id, result);
  }
 };
 BENCHMARK_TEMPLATE(find_tweet, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
  bool run(simdjson::padded_string &json, uint64_t find_id, std::string_view &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
-    bool b = yyjson_base::run(doc, find_id, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), find_id, result);
  }
 };
 BENCHMARK_TEMPLATE(find_tweet, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace find_tweet

 #endif // SIMDJSON_COMPETITION_YYJSON
@@ -1,15 +0,0 @@
-# Executable
-add_executable(from_benchmark from_benchmark.cpp)
-
-# Compile for C++20.
-if(CMAKE_CXX_STANDARD LESS 20)
-  target_compile_features(from_benchmark PRIVATE cxx_std_20)
-endif()
-# Check if -march=native is supported
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-march=native" SIMDJSON_SUPPORTS_MARCH_NATIVE)
-if(SIMDJSON_SUPPORTS_MARCH_NATIVE)
-  target_compile_options(from_benchmark PRIVATE -march=native)
-endif()
-
-target_include_directories(from_benchmark PRIVATE ${CMAKE_CURRENT_LIST_DIR}/..)
@@ -1,77 +0,0 @@
-#ifndef BENCHMARK_HELPERS_H
-#define BENCHMARK_HELPERS_H
-
-#include "event_counter.h"
-#include <atomic>
-
-event_collector collector;
-
-template <class function_type>
-std::pair<event_aggregate, size_t>
-bench(const function_type &&function, size_t min_repeat = 10,
-      size_t min_time_ns = 40'000'000, size_t max_repeat = 10000000) {
-  size_t N = min_repeat;
-  if (N == 0) {
-    N = 1;
-  }
-  event_aggregate warm_aggregate{};
-  for (size_t i = 0; i < N; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    function();
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    warm_aggregate << allocate_count;
-    if ((i + 1 == N) && (warm_aggregate.total_elapsed_ns() < min_time_ns) &&
-        (N < max_repeat)) {
-      N *= 10;
-    }
-  }
-  event_aggregate aggregate{};
-  for (size_t i = 0; i < 10; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    for (size_t i = 0; i < N; i++) {
-      function();
-    }
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    aggregate << allocate_count;
-  }
-  return {aggregate, N};
-}
-
-double pretty_print(const std::string &name, size_t num_chars,
-                    std::pair<event_aggregate, size_t> result) {
-  const auto &agg = result.first;
-  size_t N = result.second;
-  num_chars *= N;
-  printf("%-40s : %8.2f ns %8.2f GB/s", name.c_str(),
-         agg.elapsed_ns() / num_chars, num_chars / agg.elapsed_ns());
-  if (collector.has_events()) {
-    printf(" %8.2f GHz %8.2f cycles/char %8.2f ins./char %8.2f i/c",
-           agg.cycles() / agg.elapsed_ns(), agg.cycles() / num_chars,
-           agg.instructions() / num_chars, agg.instructions() / agg.cycles());
-  }
-  printf("\n");
-  return num_chars / agg.elapsed_ns();
-}
-
-double pretty_print_array(const std::string &name, size_t num_chars, size_t num_elements,
-                    std::pair<event_aggregate, size_t> result) {
-  const auto &agg = result.first;
-  size_t N = result.second;
-  num_chars *= N;
-  printf("%-40s : %8.2f ns/char %8.2f ns/value %8.2f GB/s", name.c_str(),
-         agg.elapsed_ns() / num_chars, agg.elapsed_ns() / num_elements, num_chars / agg.elapsed_ns());
-  if (collector.has_events()) {
-    printf(" %8.2f GHz %8.2f cycles/char %8.2f ins./char %8.2f ins./value %8.2f i/c",
-           agg.cycles() / agg.elapsed_ns(), agg.cycles() / num_chars,
-           agg.instructions() / num_chars, agg.instructions() / num_elements, agg.instructions() / agg.cycles());
-  }
-  printf("\n");
-  return num_chars / agg.elapsed_ns();
-}
-
-
-#endif
@@ -1,146 +0,0 @@
-#ifndef CAR_HELPERS_H
-#define CAR_HELPERS_H
-
-#include <iomanip>
-#include <random>
-#include <sstream>
-#include <vector>
-
-#include <simdjson.h>
-
-struct Car {
-  std::string make;
-  std::string model;
-  int64_t year; // We deliberately do not include the tire pressure.
-};
-
-using namespace simdjson;
-
-std::string random_car_json() {
-  static const std::vector<std::string> makes = {"Toyota", "Honda", "Ford",
-                                                 "BMW", "Mazda"};
-  static const std::vector<std::string> models = {"Camry", "Civic", "Focus",
-                                                  "320i", "3"};
-  static thread_local std::mt19937 rng{std::random_device{}()};
-  std::uniform_int_distribution<int> make_dist(0, makes.size() - 1);
-  std::uniform_int_distribution<int> model_dist(0, models.size() - 1);
-  std::uniform_int_distribution<int> year_dist(2000, 2025);
-  std::uniform_real_distribution<double> pressure_dist(30.0, 45.0);
-
-  std::ostringstream oss;
-  oss << R"({ "make": ")" << makes[make_dist(rng)] << R"(", "model": ")"
-      << models[model_dist(rng)] << R"(",  "year": )" << year_dist(rng)
-      << R"(, "tire_pressure": [ )" << std::fixed << std::setprecision(1)
-      << pressure_dist(rng) << ", " << pressure_dist(rng) << R"( ] })";
-  return oss.str();
-}
-
-std::string generate_car_json_stream(size_t N) {
-  std::ostringstream oss;
-  for (size_t i = 0; i < N; ++i) {
-    oss << random_car_json();
-    oss << "\n";
-  }
-  return oss.str();
-}
-
-std::string generate_car_json_array(size_t N) {
-  std::ostringstream oss;
-  oss << "[\n";
-  for (size_t i = 0; i < N; ++i) {
-    oss << random_car_json();
-    if (i < N - 1) {
-      oss << ",";
-    }
-    oss << "\n";
-  }
-  oss << "]";
-  return oss.str();
-}
-
-// We want to maximize C++ portability, but this is not needed with static
-// reflection (C++26).
-template <>
-simdjson_inline simdjson_result<Car>
-simdjson::ondemand::document::get() & noexcept {
-  ondemand::object obj;
-  auto error = get_object().get(obj);
-  if (error) {
-    return error;
-  }
-  Car car;
-  if ((error = obj["make"].get_string(car.make))) {
-    return error;
-  }
-  if ((error = obj["model"].get_string(car.model))) {
-    return error;
-  }
-  if ((error = obj["year"].get_int64().get(car.year))) {
-    return error;
-  }
-  return car;
-}
-
-template <>
-simdjson_inline simdjson_result<Car> simdjson::ondemand::value::get() noexcept {
-  ondemand::object obj;
-  auto error = get_object().get(obj);
-  if (error) {
-    return error;
-  }
-  Car car;
-  if ((error = obj["make"].get_string(car.make))) {
-    return error;
-  }
-  if ((error = obj["model"].get_string(car.model))) {
-    return error;
-  }
-  if ((error = obj["year"].get_int64().get(car.year))) {
-    return error;
-  }
-  return car;
-}
-
-template <>
-simdjson_inline simdjson_result<Car>
-simdjson::ondemand::document_reference::get() & noexcept {
-  ondemand::object obj;
-  auto error = get_object().get(obj);
-  if (error) {
-    return error;
-  }
-  Car car;
-  if ((error = obj["make"].get_string(car.make))) {
-    return error;
-  }
-  if ((error = obj["model"].get_string(car.model))) {
-    return error;
-  }
-  if ((error = obj["year"].get_int64().get(car.year))) {
-    return error;
-  }
-  return car;
-}
-
-template <>
-simdjson_inline simdjson_result<Car>
-simdjson::ondemand::document_reference::get() && noexcept {
-  ondemand::object obj;
-  auto error = get_object().get(obj);
-  if (error) {
-    return error;
-  }
-  Car car;
-  if ((error = obj["make"].get_string(car.make))) {
-    return error;
-  }
-  if ((error = obj["model"].get_string(car.model))) {
-    return error;
-  }
-  if ((error = obj["year"].get_int64().get(car.year))) {
-    return error;
-  }
-  return car;
-}
-
-#endif
@@ -1,132 +0,0 @@
-// We are going to assume C++20.
-
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <simdjson.h>
-#include <string>
-
-#include "benchmark_helpers.h"
-#include "car_helpers.h"
-
-using namespace simdjson;
-
-void run_benchmarks() {
-  printf("Running benchmarks on tiny input...\n");
-  simdjson::padded_string json =
-      R"({ "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9 ] })"_padded;
-  volatile size_t dummy = 0;
-  ondemand::parser parser;
-
-  // Classic On-Demand
-  pretty_print("simdjson classic", json.size(),
-               bench([&json, &dummy, &parser]() {
-                 ondemand::document doc = parser.iterate(json);
-                 Car car = doc.get<Car>();
-                 dummy = dummy + car.year;
-               }));
-
-  // Benchmark simdjson::from() without parser
-  pretty_print("simdjson::from<Car>() (no parser)", json.size(),
-               bench([&json, &dummy]() {
-                 Car car = simdjson::from(json);
-                 dummy = dummy + car.year;
-               }));
-
-  // Benchmark simdjson::from() with parser
-  pretty_print("simdjson::from<Car>() (with parser)", json.size(),
-               bench([&json, &dummy, &parser]() {
-                 Car car = simdjson::from(parser, json);
-                 dummy = dummy + car.year;
-               }));
-}
-
-void run_array_benchmarks() {
-  printf("Running benchmarks on large array...\n");
-  size_t N = 1'000'000;
-  simdjson::padded_string json = generate_car_json_array(N);
-  volatile size_t dummy = 0;
-  ondemand::parser parser;
-
-  // Classic On-Demand
-  pretty_print_array("simdjson classic", json.size(), N,
-                     bench([&json, &dummy, &parser]() {
-                       dummy = 0;
-                       ondemand::document doc = parser.iterate(json);
-                       ondemand::array array = doc.get_array();
-                       for (auto value : array) {
-                         Car car = value.get<Car>();
-                         dummy = dummy + car.year;
-                       }
-                     }));
-
-  // from with array
-  pretty_print_array("simdjson::from(json).array()", json.size(), N,
-                     bench([&json, &dummy, &parser]() {
-                       dummy = 0;
-
-                       for (auto value : simdjson::from(json).array()) {
-                         Car car = value.get<Car>();
-                         dummy = dummy + car.year;
-                       }
-                     }));
-#if SIMDJSON_SUPPORTS_RANGES_FROM
-  // Benchmark simdjson::from() without parser (EXPERIMENTAL)
-  pretty_print_array("simdjson::from<Car>() (experimental, no parser)",
-                     json.size(), N, bench([&json, &dummy]() {
-                       dummy = 0;
-                       for (Car car :
-                            simdjson::from(json) | simdjson::as<Car>()) {
-                         dummy = dummy + car.year;
-                       }
-                     }));
-
-  // Benchmark simdjson::from() with parser (EXPERIMENTAL)
-  pretty_print_array("simdjson::from<Car>() (experimental, with parser)",
-                     json.size(), N, bench([&json, &dummy, &parser]() {
-                       dummy = 0;
-                       for (Car car : simdjson::from(parser, json) |
-                                          simdjson::as<Car>()) {
-                         dummy = dummy + car.year;
-                       }
-                     }));
-#endif // SIMDJSON_SUPPORTS_RANGES_FROM
-}
-
-void run_stream_benchmarks() {
-  printf("Running stream benchmarks...\n");
-  simdjson::padded_string json = generate_car_json_stream(1'000'000);
-  volatile size_t dummy = 0;
-  ondemand::parser parser;
-
-  // Classic On-Demand
-  pretty_print("simdjson classic", json.size(),
-               bench([&json, &dummy, &parser]() {
-                 ondemand::document_stream stream = parser.iterate_many(json);
-                 for (auto doc : stream) {
-                   Car car = doc.get<Car>();
-                   dummy = dummy + car.year;
-                 }
-               }));
-  // from_many
-  pretty_print("simdjson with thread local", json.size(),
-               bench([&json, &dummy, &parser]() {
-                 ondemand::document_stream stream =
-                     ondemand::parser::get_parser().iterate_many(json);
-                 for (auto doc : stream) {
-                   Car car = doc.get<Car>();
-                   dummy = dummy + car.year;
-                 }
-               }));
-}
-
-int main() {
-  for (size_t trial = 0; trial < 3; trial++) {
-    printf("Trial %zu:\n", trial + 1);
-    run_array_benchmarks();
-    run_stream_benchmarks();
-    run_benchmarks();
-    printf("\n");
-  }
-  return EXIT_SUCCESS;
-}
@@ -9,11 +9,7 @@ simdjson_never_inline
 double bench(std::string filename, simdjson::padded_string& p) {
  std::chrono::time_point<std::chrono::steady_clock> start_clock =
      std::chrono::steady_clock::now();
-  auto error = simdjson::padded_string::load(filename).get(p);
-  if(error) {
-    std::cerr << simdjson::error_message(error) << std::endl;
-    std::abort();
-  }
+  simdjson::padded_string::load(filename).value_unsafe().swap(p);
  std::chrono::time_point<std::chrono::steady_clock> end_clock =
      std::chrono::steady_clock::now();
  std::chrono::duration<double> elapsed = end_clock - start_clock;
@@ -100,7 +100,6 @@ struct yyjson : yyjson2msgpack {
           std::string_view &result) {
    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
    result = to_msgpack(doc, reinterpret_cast<uint8_t*>(buffer));
-    yyjson_doc_free(doc);
    return true;
  }
 };
@@ -114,7 +113,6 @@ struct yyjson_insitu : yyjson2msgpack {
    yyjson_doc *doc =
        yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
    result = to_msgpack(doc, reinterpret_cast<uint8_t*>(buffer));
-    yyjson_doc_free(doc);
    return true;
  }
 };
@@ -122,4 +120,4 @@ BENCHMARK_TEMPLATE(json2msgpack, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
 } // namespace json2msgpack

-#endif // SIMDJSON_COMPETITION_YYJSON
+#endif // SIMDJSON_COMPETITION_YYJSON
@@ -24,6 +24,35 @@ struct simdjson_ondemand {

 BENCHMARK_TEMPLATE(kostya, simdjson_ondemand)->UseManualTime();

+
+#if SIMDJSON_SUPPORTS_EXTRACT
+using namespace simdjson::ondemand;
+
+struct simdjson_ondemand_extract {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    auto doc = parser.iterate(json);
+    for (ondemand::object object_point : doc.find_field("coordinates")) {
+      point p;
+      auto error = object_point.extract(
+        to{"x", p.x},
+        to{"y", p.y},
+        to{"z", p.z}
+      );
+      if(error) { return false; }
+      result.push_back(p);
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(kostya, simdjson_ondemand_extract)->UseManualTime();
+
+#endif // SIMDJSON_SUPPORTS_EXTRACT
+
 } // namespace kostya

 #endif // SIMDJSON_EXCEPTIONS
@@ -49,26 +49,18 @@ struct yyjson_base {

 struct yyjson : yyjson_base {
  bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
  }
 };
 BENCHMARK_TEMPLATE(kostya, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
  bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
  }
 };
 BENCHMARK_TEMPLATE(kostya, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace kostya

 #endif // SIMDJSON_COMPETITION_YYJSON
@@ -23,29 +23,7 @@ struct simdjson_ondemand {
 };

 BENCHMARK_TEMPLATE(large_random, simdjson_ondemand)->UseManualTime();
-#if SIMDJSON_STATIC_REFLECTION

-struct simdjson_ondemand_static_reflect {
-  static constexpr diff_flags DiffFlags = diff_flags::NONE;
-
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    auto doc = parser.iterate(json);
-    if(auto e = doc.get_array().get<std::vector<point>>(result); e) { return false; }
-    // We can also do it like so:
-    //for (ondemand::object coord : doc) {
-    //  result.emplace_back(coord.get<point>());
-    //}
-    // It seems that doing the reflection is slower than doing the manual lookup.
-    // E.g., it is faster if we do result.emplace_back(coord["x"], coord["y"], coord["z"]);
-    return true;
-  }
-};
-BENCHMARK_TEMPLATE(large_random, simdjson_ondemand_static_reflect)->UseManualTime();
-
-
-#endif
 } // namespace large_random

 #endif // SIMDJSON_EXCEPTIONS
@@ -47,26 +47,18 @@ struct yyjson_base {

 struct yyjson : yyjson_base {
  bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
  }
 };
 BENCHMARK_TEMPLATE(large_random, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
  bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
  }
 };
 BENCHMARK_TEMPLATE(large_random, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace large_random

 #endif // SIMDJSON_COMPETITION_YYJSON
@@ -9,7 +9,7 @@ namespace partial_tweets {
 using namespace simdjson;

 struct simdjson_ondemand {
-  using StringType=std::string_view;
+  using StringType = std::string_view;

  ondemand::parser parser{};

@@ -43,6 +43,48 @@ struct simdjson_ondemand {

 BENCHMARK_TEMPLATE(partial_tweets, simdjson_ondemand)->UseManualTime();

+
+#if SIMDJSON_SUPPORTS_EXTRACT
+
+using namespace simdjson::ondemand;
+
+struct simdjson_ondemand_extract {
+  using StringType = std::string_view;
+  ondemand::parser parser{};
+  bool run(simdjson::padded_string &json, std::vector<tweet<std::string_view>> &result) {
+    // Walk the document, parsing the tweets as we go
+    auto doc = parser.iterate(json);
+    for (ondemand::object tweet_object : doc.find_field("statuses")) {
+      tweet<std::string_view> t;
+      auto error = tweet_object.extract(
+        to{"created_at", t.created_at},
+        to{"id", t.id},
+        to{"text", t.result},
+        to{"in_reply_to_status_id", [&t](auto val) {
+          if(val.is_null()) {
+            t.in_reply_to_status_id = 0;
+          } else {
+            t.in_reply_to_status_id = val;
+          }
+         }},
+        to{"user", sub{
+          to{"id", t.user.id},
+          to{"screen_name", t.user.screen_name},
+        }},
+        to{"retweet_count", t.retweet_count},
+        to{"favorite_count", t.favorite_count});
+        if(error) { return false; }
+        result.push_back(t);
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(partial_tweets, simdjson_ondemand_extract)->UseManualTime();
+
+
+#endif
+
 } // namespace partial_tweets

 #endif // SIMDJSON_EXCEPTIONS
@@ -62,26 +62,19 @@ struct yyjson_base {

 struct yyjson : yyjson_base {
  bool run(simdjson::padded_string &json, std::vector<tweet<std::string_view>> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
  }
 };
 BENCHMARK_TEMPLATE(partial_tweets, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
  bool run(simdjson::padded_string &json, std::vector<tweet<std::string_view>> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
  }
 };
 BENCHMARK_TEMPLATE(partial_tweets, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace partial_tweets

 #endif // SIMDJSON_COMPETITION_YYJSON
+
@@ -1,48 +0,0 @@
-# Include reflect-cpp
-CPMAddPackage(
-  NAME reflect-cpp
-  GITHUB_REPOSITORY getml/reflect-cpp
-  GIT_TAG v0.17.0
-  EXCLUDE_FROM_ALL YES
-)
-
-option(SIMDJSON_USE_RUST "Build the static_reflect benchmark" OFF)
-
-if(SIMDJSON_USE_RUST)
-  if(NOT WIN32)
-  # We want the check whether Rust is available before trying to build a crate.
-  CPMAddPackage(
-    NAME corrosion
-    GITHUB_REPOSITORY corrosion-rs/corrosion
-    VERSION 0.4.4
-    DOWNLOAD_ONLY ON
-    OPTIONS "Rust_FIND_QUIETLY OFF"
-  )
-  include("${corrosion_SOURCE_DIR}/cmake/FindRust.cmake")
-  endif()
-
-  if(RUST_FOUND)
-    message(STATUS "Rust found: " ${Rust_VERSION} )
-    add_subdirectory("${corrosion_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/corrosion" EXCLUDE_FROM_ALL)
-    # Important: we want to build in release mode!
-    corrosion_import_crate(MANIFEST_PATH "serde-benchmark/Cargo.toml" NO_LINKER_OVERRIDE PROFILE release)
-  else()
-    message(STATUS "Rust/Cargo is unavailable." )
-    message(STATUS "We will not benchmark serde-benchmark." )
-    if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-      message(STATUS "Under macOS, you may be able to install rust with")
-      message(STATUS "curl https://sh.rustup.rs -sSf | sh")
-    elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-      message(STATUS "Under Linux, you may be able to install rust with a command such as")
-      message(STATUS "apt-get install cargo" )
-      message(STATUS "or" )
-      message(STATUS "curl https://sh.rustup.rs -sSf | sh")
-    endif()
-  endif()
-else(SIMDJSON_USE_RUST)
-  message(STATUS "We will not benchmark serde-benchmark." )
-endif(SIMDJSON_USE_RUST)
-
-# Add the benchmark executable targets
-add_subdirectory(twitter_benchmark)
-add_subdirectory(citm_catalog_benchmark)
@@ -1,52 +0,0 @@
-#ifndef BENCHMARK_HELPER_HPP
-#define BENCHMARK_HELPER_HPP
-#include "event_counter.h"
-#include <atomic>
-
-inline event_collector &get_collector() {
-  static event_collector collector;
-  return collector;
-}
-
-template <class function_type>
-event_aggregate bench(const function_type &function, size_t min_repeat = 10,
-                      size_t min_time_ns = 1000000000,
-                      size_t max_repeat = 100000) {
-  event_collector &collector = get_collector();
-  event_aggregate aggregate{};
-  size_t N = min_repeat;
-  if (N == 0) {
-    N = 1;
-  }
-  for (size_t i = 0; i < N; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    function();
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    aggregate << allocate_count;
-    if ((i + 1 == N) && (aggregate.total_elapsed_ns() < min_time_ns) &&
-        (N < max_repeat)) {
-      N *= 10;
-    }
-  }
-  return aggregate;
-}
-
-// Source of the 2 functions below:
-// https://github.com/simdutf/simdutf/blob/master/benchmarks/base64/benchmark_base64.cpp
-inline void pretty_print(size_t strings, size_t bytes, std::string name,
-                         event_aggregate agg) {
-  event_collector &collector = get_collector();
-  printf("%-60s : ", name.c_str());
-  printf(" %5.2f MB/s ", bytes * 1000 / agg.elapsed_ns());
-  printf(" %5.2f Ms/s ", strings * 1000 / agg.elapsed_ns());
-  if (collector.has_events()) {
-    printf(" %5.2f GHz ", agg.cycles() / agg.elapsed_ns());
-    printf(" %5.2f c/b ", agg.cycles() / bytes);
-    printf(" %5.2f i/b ", agg.instructions() / bytes);
-    printf(" %5.2f i/c ", agg.instructions() / agg.cycles());
-  }
-  printf("\n");
-}
-#endif
@@ -1,40 +0,0 @@
-add_executable(benchmark_serialization_citm_catalog benchmark_serialization_citm_catalog.cpp)
-add_executable(benchmark_parsing_citm benchmark_parsing_citm.cpp)
-
-# Link with Rust benchmarking code if available
-if(TARGET serde-benchmark)
-    message(STATUS "serde-benchmark target was created. Linking CITM catalog benchmark with serde-benchmark.")
-    target_link_libraries(benchmark_serialization_citm_catalog PRIVATE serde-benchmark)
-    target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
-endif()
-
-target_link_libraries(benchmark_serialization_citm_catalog PRIVATE simdjson::simdjson nlohmann_json)
-target_link_libraries(benchmark_serialization_citm_catalog PRIVATE reflectcpp)
-target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_BENCH_CPP_REFLECT=1)
-
-if(TARGET yyjson)
-    target_link_libraries(benchmark_serialization_citm_catalog PRIVATE yyjson)
-    target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_COMPETITION_YYJSON)
-endif()
-
-target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE JSON_FILE="${BENCH_CITM_JSON}")
-
-# Configuration for parsing benchmark
-if(TARGET serde-benchmark)
-    target_link_libraries(benchmark_parsing_citm PRIVATE serde-benchmark)
-    target_compile_definitions(benchmark_parsing_citm PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
-endif()
-
-target_link_libraries(benchmark_parsing_citm PRIVATE simdjson::simdjson nlohmann_json)
-
-if(TARGET rapidjson)
-    target_link_libraries(benchmark_parsing_citm PRIVATE rapidjson)
-    target_compile_definitions(benchmark_parsing_citm PRIVATE SIMDJSON_COMPETITION_RAPIDJSON)
-endif()
-
-if(TARGET yyjson)
-    target_link_libraries(benchmark_parsing_citm PRIVATE yyjson)
-    target_compile_definitions(benchmark_parsing_citm PRIVATE SIMDJSON_COMPETITION_YYJSON)
-endif()
-
-target_compile_definitions(benchmark_parsing_citm PRIVATE JSON_FILE="${BENCH_CITM_JSON}")
@@ -1,563 +0,0 @@
-#include <cassert>
-#include <cstdlib>
-#include <ctime>
-#include <format>
-#include <fstream>
-#include <iostream>
-#include <nlohmann/json.hpp>
-#include <simdjson.h>
-#include <string>
-#include "citm_catalog_data.h"
-#include "nlohmann_citm_catalog_data.h"
-#include "../benchmark_utils/benchmark_helper.h"
-
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-#include "rapidjson_citm_catalog_data.h"
-#endif
-
-#ifdef SIMDJSON_COMPETITION_YYJSON
-#include "yyjson_citm_catalog_data.h"
-#endif
-
-#ifdef SIMDJSON_RUST_VERSION
-#include "../serde-benchmark/serde_benchmark.h"
-
-void bench_rust_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_rust_parsing",
-               bench([&json_str, &result]() {
-                 serde_benchmark::CitmCatalog *catalog = serde_benchmark::citm_from_str(json_str.c_str(), json_str.size());
-                 result = (catalog != nullptr);
-                 if (catalog) {
-                   serde_benchmark::free_citm(catalog);
-                 }
-                 if (!result) {
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-template <class T> void bench_simdjson_static_reflection_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  // Pre-allocate padded buffer outside the benchmark loop
-  std::string mutable_json = json_str;
-  simdjson::pad(mutable_json);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_simdjson_static_reflection_parsing",
-               bench([&mutable_json, &result]() {
-                 simdjson::ondemand::parser parser;
-                 simdjson::ondemand::document doc;
-                 if(parser.iterate(mutable_json).get(doc)) {
-                   result = false;
-                   return;
-                 }
-                 T my_struct;
-                 if(doc.get<T>().get(my_struct)) {
-                   result = false;
-                 }
-                 if (!result) {
-                   printf("parse error\n");
-                 }
-               }));
-}
-
-#if SIMDJSON_STATIC_REFLECTION
-template <class T> void bench_simdjson_from_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  // Pre-allocate padded buffer outside the benchmark loop
-  simdjson::padded_string padded = simdjson::padded_string(json_str);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_simdjson_from_parsing",
-               bench([&padded, &result]() {
-                 T my_struct;
-                 auto err = simdjson::from(padded).get(my_struct);
-                  if (err) {
-                    result = false;
-                    printf("parse error: %s\n", simdjson::error_message(err));
-                    return;
-                  }
-               }));
-}
-#endif
-
-// nlohmann::json deserialization functions
-void from_json(const nlohmann::json &j, CITMPrice &p) {
-    j.at("amount").get_to(p.amount);
-    j.at("audienceSubCategoryId").get_to(p.audienceSubCategoryId);
-    j.at("seatCategoryId").get_to(p.seatCategoryId);
-}
-
-void from_json(const nlohmann::json &j, CITMArea &a) {
-    j.at("areaId").get_to(a.areaId);
-    j.at("blockIds").get_to(a.blockIds);
-}
-
-void from_json(const nlohmann::json &j, CITMSeatCategory &s) {
-    j.at("areas").get_to(s.areas);
-    j.at("seatCategoryId").get_to(s.seatCategoryId);
-}
-
-void from_json(const nlohmann::json &j, CITMPerformance &p) {
-    j.at("id").get_to(p.id);
-    j.at("eventId").get_to(p.eventId);
-    if (j.contains("logo") && !j["logo"].is_null()) {
-        p.logo = j["logo"].get<std::string>();
-    }
-    if (j.contains("name") && !j["name"].is_null()) {
-        p.name = j["name"].get<std::string>();
-    }
-    j.at("prices").get_to(p.prices);
-    j.at("seatCategories").get_to(p.seatCategories);
-    if (j.contains("seatMapImage") && !j["seatMapImage"].is_null()) {
-        p.seatMapImage = j["seatMapImage"].get<std::string>();
-    }
-    j.at("start").get_to(p.start);
-    j.at("venueCode").get_to(p.venueCode);
-}
-
-void from_json(const nlohmann::json &j, CITMEvent &e) {
-    j.at("id").get_to(e.id);
-    j.at("name").get_to(e.name);
-    if (j.contains("description") && !j["description"].is_null()) {
-        e.description = j["description"].get<std::string>();
-    }
-    if (j.contains("logo") && !j["logo"].is_null()) {
-        e.logo = j["logo"].get<std::string>();
-    }
-    j.at("subTopicIds").get_to(e.subTopicIds);
-    if (j.contains("subjectCode") && !j["subjectCode"].is_null()) {
-        e.subjectCode = j["subjectCode"].get<std::string>();
-    }
-    if (j.contains("subtitle") && !j["subtitle"].is_null()) {
-        e.subtitle = j["subtitle"].get<std::string>();
-    }
-    j.at("topicIds").get_to(e.topicIds);
-}
-
-void from_json(const nlohmann::json &j, CitmCatalog &c) {
-    j.at("events").get_to(c.events);
-    j.at("performances").get_to(c.performances);
-}
-
-CitmCatalog nlohmann_deserialize(const std::string &json_str) {
-    nlohmann::json j = nlohmann::json::parse(json_str);
-    return j.get<CitmCatalog>();
-}
-
-void bench_nlohmann_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_nlohmann_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   CitmCatalog data = nlohmann_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-CitmCatalog rapidjson_deserialize(const std::string &json_str) {
-    rapidjson::Document doc;
-    doc.Parse(json_str.c_str());
-
-    if (doc.HasParseError()) {
-        throw std::runtime_error("RapidJSON parse error");
-    }
-
-    CitmCatalog catalog;
-
-    // Parse events
-    if (doc.HasMember("events") && doc["events"].IsObject()) {
-        for (auto& m : doc["events"].GetObject()) {
-            CITMEvent event;
-            const auto& e = m.value;
-
-            event.id = e["id"].GetUint64();
-            event.name = e["name"].GetString();
-            if (e.HasMember("description") && !e["description"].IsNull()) {
-                event.description = e["description"].GetString();
-            }
-            if (e.HasMember("logo") && !e["logo"].IsNull()) {
-                event.logo = e["logo"].GetString();
-            }
-
-            event.subTopicIds.clear();
-            for (auto& id : e["subTopicIds"].GetArray()) {
-                event.subTopicIds.push_back(id.GetUint64());
-            }
-
-            if (e.HasMember("subjectCode") && !e["subjectCode"].IsNull()) {
-                event.subjectCode = e["subjectCode"].GetString();
-            }
-            if (e.HasMember("subtitle") && !e["subtitle"].IsNull()) {
-                event.subtitle = e["subtitle"].GetString();
-            }
-
-            event.topicIds.clear();
-            for (auto& id : e["topicIds"].GetArray()) {
-                event.topicIds.push_back(id.GetUint64());
-            }
-
-            catalog.events[m.name.GetString()] = event;
-        }
-    }
-
-    // Parse performances
-    if (doc.HasMember("performances") && doc["performances"].IsArray()) {
-        for (auto& p : doc["performances"].GetArray()) {
-            CITMPerformance perf;
-
-            perf.id = p["id"].GetUint64();
-            perf.eventId = p["eventId"].GetUint64();
-            if (p.HasMember("logo") && !p["logo"].IsNull()) {
-                perf.logo = p["logo"].GetString();
-            }
-            if (p.HasMember("name") && !p["name"].IsNull()) {
-                perf.name = p["name"].GetString();
-            }
-
-            // Parse prices
-            for (auto& price : p["prices"].GetArray()) {
-                CITMPrice pr;
-                pr.amount = price["amount"].GetUint64();
-                pr.audienceSubCategoryId = price["audienceSubCategoryId"].GetUint64();
-                pr.seatCategoryId = price["seatCategoryId"].GetUint64();
-                perf.prices.push_back(pr);
-            }
-
-            // Parse seat categories
-            for (auto& sc : p["seatCategories"].GetArray()) {
-                CITMSeatCategory seatCat;
-                seatCat.seatCategoryId = sc["seatCategoryId"].GetUint64();
-
-                for (auto& area : sc["areas"].GetArray()) {
-                    CITMArea ar;
-                    ar.areaId = area["areaId"].GetUint64();
-                    for (auto& block : area["blockIds"].GetArray()) {
-                        ar.blockIds.push_back(block.GetUint64());
-                    }
-                    seatCat.areas.push_back(ar);
-                }
-                perf.seatCategories.push_back(seatCat);
-            }
-
-            if (p.HasMember("seatMapImage") && !p["seatMapImage"].IsNull()) {
-                perf.seatMapImage = p["seatMapImage"].GetString();
-            }
-            perf.start = p["start"].GetUint64();
-            perf.venueCode = p["venueCode"].GetString();
-
-            catalog.performances.push_back(perf);
-        }
-    }
-
-    return catalog;
-}
-
-void bench_rapidjson_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_rapidjson_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   CitmCatalog data = rapidjson_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-#ifdef SIMDJSON_COMPETITION_YYJSON
-CitmCatalog yyjson_deserialize(const std::string &json_str) {
-    yyjson_doc *doc = yyjson_read(json_str.c_str(), json_str.size(), 0);
-    if (!doc) {
-        throw std::runtime_error("YYJson parse error");
-    }
-
-    yyjson_val *root = yyjson_doc_get_root(doc);
-    CitmCatalog catalog;
-
-    // Parse events
-    yyjson_val *events = yyjson_obj_get(root, "events");
-    if (events) {
-        size_t idx, max;
-        yyjson_val *key, *val;
-        yyjson_obj_foreach(events, idx, max, key, val) {
-            CITMEvent event;
-
-            event.id = yyjson_get_uint(yyjson_obj_get(val, "id"));
-            const char* name = yyjson_get_str(yyjson_obj_get(val, "name"));
-            if (name) event.name = name;
-
-            yyjson_val *desc = yyjson_obj_get(val, "description");
-            if (desc && !yyjson_is_null(desc)) {
-                const char* str = yyjson_get_str(desc);
-                if (str) event.description = str;
-            }
-
-            yyjson_val *logo = yyjson_obj_get(val, "logo");
-            if (logo && !yyjson_is_null(logo)) {
-                const char* str = yyjson_get_str(logo);
-                if (str) event.logo = str;
-            }
-
-            yyjson_val *subTopics = yyjson_obj_get(val, "subTopicIds");
-            if (subTopics) {
-                size_t sidx, smax;
-                yyjson_val *sval;
-                yyjson_arr_foreach(subTopics, sidx, smax, sval) {
-                    event.subTopicIds.push_back(yyjson_get_uint(sval));
-                }
-            }
-
-            yyjson_val *subjectCode = yyjson_obj_get(val, "subjectCode");
-            if (subjectCode && !yyjson_is_null(subjectCode)) {
-                const char* str = yyjson_get_str(subjectCode);
-                if (str) event.subjectCode = str;
-            }
-
-            yyjson_val *subtitle = yyjson_obj_get(val, "subtitle");
-            if (subtitle && !yyjson_is_null(subtitle)) {
-                const char* str = yyjson_get_str(subtitle);
-                if (str) event.subtitle = str;
-            }
-
-            yyjson_val *topics = yyjson_obj_get(val, "topicIds");
-            if (topics) {
-                size_t tidx, tmax;
-                yyjson_val *tval;
-                yyjson_arr_foreach(topics, tidx, tmax, tval) {
-                    event.topicIds.push_back(yyjson_get_uint(tval));
-                }
-            }
-
-            const char* keyStr = yyjson_get_str(key);
-            if (keyStr) {
-                catalog.events[keyStr] = event;
-            }
-        }
-    }
-
-    // Parse performances
-    yyjson_val *performances = yyjson_obj_get(root, "performances");
-    if (performances) {
-        size_t idx, max;
-        yyjson_val *val;
-        yyjson_arr_foreach(performances, idx, max, val) {
-            CITMPerformance perf;
-
-            perf.id = yyjson_get_uint(yyjson_obj_get(val, "id"));
-            perf.eventId = yyjson_get_uint(yyjson_obj_get(val, "eventId"));
-
-            yyjson_val *logo = yyjson_obj_get(val, "logo");
-            if (logo && !yyjson_is_null(logo)) {
-                const char* str = yyjson_get_str(logo);
-                if (str) perf.logo = str;
-            }
-
-            yyjson_val *name = yyjson_obj_get(val, "name");
-            if (name && !yyjson_is_null(name)) {
-                const char* str = yyjson_get_str(name);
-                if (str) perf.name = str;
-            }
-
-            // Parse prices
-            yyjson_val *prices = yyjson_obj_get(val, "prices");
-            if (prices) {
-                size_t pidx, pmax;
-                yyjson_val *pval;
-                yyjson_arr_foreach(prices, pidx, pmax, pval) {
-                    CITMPrice price;
-                    price.amount = yyjson_get_uint(yyjson_obj_get(pval, "amount"));
-                    price.audienceSubCategoryId = yyjson_get_uint(yyjson_obj_get(pval, "audienceSubCategoryId"));
-                    price.seatCategoryId = yyjson_get_uint(yyjson_obj_get(pval, "seatCategoryId"));
-                    perf.prices.push_back(price);
-                }
-            }
-
-            // Parse seat categories
-            yyjson_val *seatCats = yyjson_obj_get(val, "seatCategories");
-            if (seatCats) {
-                size_t scidx, scmax;
-                yyjson_val *scval;
-                yyjson_arr_foreach(seatCats, scidx, scmax, scval) {
-                    CITMSeatCategory seatCat;
-                    seatCat.seatCategoryId = yyjson_get_uint(yyjson_obj_get(scval, "seatCategoryId"));
-
-                    yyjson_val *areas = yyjson_obj_get(scval, "areas");
-                    if (areas) {
-                        size_t aidx, amax;
-                        yyjson_val *aval;
-                        yyjson_arr_foreach(areas, aidx, amax, aval) {
-                            CITMArea area;
-                            area.areaId = yyjson_get_uint(yyjson_obj_get(aval, "areaId"));
-
-                            yyjson_val *blocks = yyjson_obj_get(aval, "blockIds");
-                            if (blocks) {
-                                size_t bidx, bmax;
-                                yyjson_val *bval;
-                                yyjson_arr_foreach(blocks, bidx, bmax, bval) {
-                                    area.blockIds.push_back(yyjson_get_uint(bval));
-                                }
-                            }
-                            seatCat.areas.push_back(area);
-                        }
-                    }
-                    perf.seatCategories.push_back(seatCat);
-                }
-            }
-
-            yyjson_val *seatMapImage = yyjson_obj_get(val, "seatMapImage");
-            if (seatMapImage && !yyjson_is_null(seatMapImage)) {
-                const char* str = yyjson_get_str(seatMapImage);
-                if (str) perf.seatMapImage = str;
-            }
-
-            perf.start = yyjson_get_uint(yyjson_obj_get(val, "start"));
-            const char* venueCode = yyjson_get_str(yyjson_obj_get(val, "venueCode"));
-            if (venueCode) perf.venueCode = venueCode;
-
-            catalog.performances.push_back(perf);
-        }
-    }
-
-    yyjson_doc_free(doc);
-    return catalog;
-}
-
-void bench_yyjson_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_yyjson_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   CitmCatalog data = yyjson_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-std::string read_file(std::string filename) {
-  printf("# Reading file %s\n", filename.c_str());
-  constexpr size_t read_size = 4096;
-  auto stream = std::ifstream(filename);
-  stream.exceptions(std::ios_base::badbit);
-
-  if (!stream) {
-    std::cerr << "Error: Failed to open file " << filename << std::endl;
-    exit(EXIT_FAILURE);
-  }
-
-  std::string out;
-  auto buf = std::string(read_size, '\0');
-  while (stream.read(&buf[0], read_size)) {
-    out.append(buf, 0, size_t(stream.gcount()));
-  }
-  out.append(buf, 0, size_t(stream.gcount()));
-  return out;
-}
-
-// Function to check if benchmark name matches any of the comma-separated filters
-bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  if (filter.empty()) return true;
-
-  // Split filter by comma
-  size_t start = 0;
-  size_t end = filter.find(',');
-  while (end != std::string::npos) {
-    std::string token = filter.substr(start, end - start);
-    if (benchmark_name.find(token) != std::string::npos) {
-      return true;
-    }
-    start = end + 1;
-    end = filter.find(',', start);
-  }
-  // Check last token
-  std::string token = filter.substr(start);
-  return benchmark_name.find(token) != std::string::npos;
-}
-
-int main(int argc, char *argv[]) {
-  // Get the JSON file path from preprocessor or use default
-  std::string filename;
-#ifdef JSON_FILE
-  filename = JSON_FILE;
-#else
-  filename = "jsonexamples/citm_catalog.json";
-#endif
-
-  std::string json_str = read_file(filename);
-
-  // Parse command-line arguments for filter
-  std::string filter;
-  for (int i = 1; i < argc; i++) {
-    std::string arg = argv[i];
-    if (arg == "-f" && i + 1 < argc) {
-      filter = argv[i + 1];
-      printf("# Filter: %s\n", filter.c_str());
-      i++;
-    }
-  }
-
-  // If no filter provided, run all benchmarks
-  if (filter.empty()) {
-    printf("# Running all benchmarks (use -f <filter> to run specific ones)\n");
-  }
-
-  // Benchmarking the parsing
-  if (matches_filter("nlohmann", filter)) {
-    bench_nlohmann_parsing(json_str);
-  }
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-  if (matches_filter("rapidjson", filter)) {
-    bench_rapidjson_parsing(json_str);
-  }
-#endif
-#ifdef SIMDJSON_COMPETITION_YYJSON
-  if (matches_filter("yyjson", filter)) {
-    bench_yyjson_parsing(json_str);
-  }
-#endif
-  if (matches_filter("simdjson_static_reflection", filter)) {
-    bench_simdjson_static_reflection_parsing<CitmCatalog>(json_str);
-  }
-#if SIMDJSON_STATIC_REFLECTION
-  if (matches_filter("simdjson_from", filter)) {
-    bench_simdjson_from_parsing<CitmCatalog>(json_str);
-  }
-#endif
-#ifdef SIMDJSON_RUST_VERSION
-  if (matches_filter("rust", filter)) {
-    printf("# Note: Rust/Serde parsing test\n");
-    bench_rust_parsing(json_str);
-  }
-#endif
-  return EXIT_SUCCESS;
-}
@@ -1,315 +0,0 @@
-#include <cassert>
-#include <cstdlib>
-#include <ctime>
-#include <format>
-#include <fstream>
-#include <iostream>
-#include <nlohmann/json.hpp>
-#include <simdjson.h>
-#include <string>
-#include "citm_catalog_data.h"
-#include "nlohmann_citm_catalog_data.h"
-#include "../benchmark_utils/benchmark_helper.h"
-
-#ifdef SIMDJSON_COMPETITION_YYJSON
-#include "yyjson_citm_catalog_data.h"
-#endif
-
-#if SIMDJSON_BENCH_CPP_REFLECT
-#include <rfl.hpp>
-#include <rfl/json.hpp>
-void bench_reflect_cpp(CitmCatalog &data) {
-  std::string output = rfl::json::write(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_reflect_cpp",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = rfl::json::write(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif // SIMDJSON_BENCH_CPP_REFLECT
-
-#ifdef SIMDJSON_RUST_VERSION
-#include "../serde-benchmark/serde_benchmark.h"
-
-void bench_rust(serde_benchmark::CitmCatalog *data) {
-  serde_benchmark::set_citm_data(data);
-  size_t output_volume = serde_benchmark::serialize_citm_to_string();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_rust",
-               bench([&measured_volume, &output_volume]() {
-                 measured_volume = serde_benchmark::serialize_citm_to_string();
-               }));
-}
-#endif // SIMDJSON_RUST_VERSION
-
-void bench_nlohmann(CitmCatalog &data) {
-  std::string output = nlohmann_serialize(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_nlohmann",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = nlohmann_serialize(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-#ifdef SIMDJSON_COMPETITION_YYJSON
-void bench_yyjson(CitmCatalog &data) {
-  std::string output = yyjson_serialize_citm(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_yyjson",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = yyjson_serialize_citm(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif
-
-// Fair allocation variant: allocates fresh buffer each iteration (matches other libraries)
-void bench_simdjson_static_reflection(CitmCatalog &data) {
-  // First run to determine expected size
-  simdjson::builder::string_builder sb_init;
-  simdjson::builder::append(sb_init, data);
-  std::string_view p_init;
-  if(sb_init.view().get(p_init)) {
-    std::cerr << "Error!" << std::endl;
-  }
-  size_t output_volume = p_init.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
-               bench([&data, &measured_volume, &output_volume]() {
-                 // Fresh allocation each iteration - fair comparison
-                 simdjson::builder::string_builder sb;
-                 simdjson::builder::append(sb, data);
-                 std::string_view p;
-                 if(sb.view().get(p)) {
-                   std::cerr << "Error!" << std::endl;
-                 }
-                 measured_volume = sb.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-// Optimized variant: reuses buffer across iterations (shows API potential)
-void bench_simdjson_static_reflection_reuse(CitmCatalog &data) {
-  simdjson::builder::string_builder sb;
-  simdjson::builder::append(sb, data);
-  std::string_view p;
-  if(sb.view().get(p)) {
-    std::cerr << "Error!" << std::endl;
-  }
-  size_t output_volume = p.size();
-  sb.clear();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_reuse_buffer",
-               bench([&data, &measured_volume, &output_volume, &sb]() {
-                 sb.clear();
-                 simdjson::builder::append(sb, data);
-                 std::string_view p;
-                 if(sb.view().get(p)) {
-                   std::cerr << "Error!" << std::endl;
-                 }
-                 measured_volume = sb.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-#if SIMDJSON_STATIC_REFLECTION
-// Fair allocation variant: allocates fresh string each iteration
-void bench_simdjson_to(CitmCatalog &data) {
-  // First run to determine size
-  std::string output_init;
-  if (simdjson::error_code err = simdjson::builder::to_json(data, output_init); err) {
-    std::cerr << "Error in to_json initialization!" << simdjson::error_message(err) << std::endl;
-    return;
-  }
-  size_t output_volume = output_init.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_to",
-               bench([&data, &measured_volume, &output_volume]() {
-                 // Fresh allocation each iteration - fair comparison
-                 std::string output;
-                 if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
-                   std::cerr << "Error in to_json!" << simdjson::error_message(err) << std::endl;
-                   return;
-                 }
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-// Optimized variant: reuses pre-allocated string
-void bench_simdjson_to_reuse(CitmCatalog &data) {
-  std::string output;
-  if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
-    std::cerr << "Error in to_json initialization!" << simdjson::error_message(err) << std::endl;
-    return;
-  }
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  // Pre-allocate string with sufficient capacity to avoid reallocation
-  output.reserve(output_volume * 2);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_to_reuse",
-               bench([&data, &measured_volume, &output_volume, &output]() {
-                 // Reuse the pre-allocated string - avoids allocation
-                 if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
-                   std::cerr << "Error in to_json!" << simdjson::error_message(err) << std::endl;
-                   return;
-                 }
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif
-
-simdjson::padded_string read_file(const std::string &file_path, size_t read_size = 65536) {
-  std::ifstream stream(file_path, std::ios::binary);
-  if(!stream) {
-    std::cerr << "Could not open file '" << file_path << "'" << std::endl;
-    exit(EXIT_FAILURE);
-  }
-  stream.exceptions(std::ios_base::badbit);
-  simdjson::padded_string_builder builder;
-  std::string buf(read_size, '\0');
-  while (stream.read(&buf[0], read_size)) {
-    builder.append(buf.data(), size_t(stream.gcount()));
-  }
-  builder.append(buf.data(), size_t(stream.gcount()));
-  return builder.convert();
-}
-
-// Function to check if benchmark name matches any of the comma-separated filters
-bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  if (filter.empty()) return true;
-
-  // Split filter by comma
-  size_t start = 0;
-  size_t end = filter.find(',');
-  while (end != std::string::npos) {
-    std::string token = filter.substr(start, end - start);
-    if (benchmark_name.find(token) != std::string::npos) {
-      return true;
-    }
-    start = end + 1;
-    end = filter.find(',', start);
-  }
-  // Check last token
-  std::string token = filter.substr(start);
-  return benchmark_name.find(token) != std::string::npos;
-}
-
-int main(int argc, char* argv[]) {
-  std::string filter;
-
-  // Parse command-line arguments
-  for (int i = 1; i < argc; ++i) {
-      if (strcmp(argv[i], "-f") == 0 || strcmp(argv[i], "--filter") == 0) {
-          if (i + 1 < argc) {
-              filter = argv[++i];
-          } else {
-              std::cerr << "Error: -f/--filter requires an argument" << std::endl;
-              return EXIT_FAILURE;
-          }
-      }
-  }
-  // Testing correctness of round-trip (serialization + deserialization)
-  simdjson::padded_string json_str = read_file(JSON_FILE);
-
-  // Loading up the data into a structure.
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc;
-  if(parser.iterate(json_str).get(doc)) {
-    std::cerr << "Error loading the document!" << std::endl;
-    return EXIT_FAILURE;
-  }
-  CitmCatalog my_struct;
-  if(doc.get<CitmCatalog>().get(my_struct)) {
-    std::cerr << "Error loading CitmCatalog!" << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  // Benchmarking the serialization
-  // Note: simdjson benchmarks include both "fair" (fresh allocation) and "reuse" (buffer reuse) variants
-  // The "fair" variants allocate fresh memory each iteration, matching other libraries' behavior
-  // The "reuse" variants demonstrate the API's potential when buffer reuse is possible
-
-  if (matches_filter("nlohmann", filter)) {
-    bench_nlohmann(my_struct);
-  }
-#ifdef SIMDJSON_COMPETITION_YYJSON
-  if (matches_filter("yyjson", filter)) {
-    bench_yyjson(my_struct);
-  }
-#endif
-  if (matches_filter("simdjson_static_reflection", filter)) {
-    bench_simdjson_static_reflection(my_struct);
-  }
-  if (matches_filter("simdjson_reuse", filter)) {
-    bench_simdjson_static_reflection_reuse(my_struct);
-  }
-#if SIMDJSON_STATIC_REFLECTION
-  if (matches_filter("simdjson_to", filter)) {
-    bench_simdjson_to(my_struct);
-  }
-  if (matches_filter("simdjson_to_reuse", filter)) {
-    bench_simdjson_to_reuse(my_struct);
-  }
-#endif
-#ifdef SIMDJSON_RUST_VERSION
-  if (matches_filter("rust", filter)) {
-    // Create a Rust-compatible CitmCatalog structure from the JSON string
-    serde_benchmark::CitmCatalog* rust_data =
-      serde_benchmark::citm_from_str(json_str.data(), json_str.size());
-
-    if (rust_data == nullptr) {
-      printf("# Failed to initialize Rust data structure\n");
-    } else {
-      bench_rust(rust_data);
-      serde_benchmark::free_citm(rust_data);
-    }
-  }
-#endif
-#if SIMDJSON_BENCH_CPP_REFLECT
-  if (matches_filter("reflect_cpp", filter)) {
-    bench_reflect_cpp(my_struct);
-  }
-#endif
-  return EXIT_SUCCESS;
-}
@@ -1,68 +0,0 @@
-#ifndef CITM_CATALOG_DATA_H
-#define CITM_CATALOG_DATA_H
-
-#include <string>
-#include <vector>
-#include <map>
-#include <optional>
-#include <cstdint>
-
-// Price structure - field names must match JSON keys for reflection
-struct CITMPrice {
-    uint64_t amount;
-    uint64_t audienceSubCategoryId;
-    uint64_t seatCategoryId;
-    bool operator==(const CITMPrice&) const = default;
-};
-
-struct CITMArea {
-    uint64_t areaId;
-    std::vector<uint64_t> blockIds;
-    bool operator==(const CITMArea&) const = default;
-};
-
-struct CITMSeatCategory {
-    std::vector<CITMArea> areas;
-    uint64_t seatCategoryId;
-    bool operator==(const CITMSeatCategory&) const = default;
-};
-
-struct CITMPerformance {
-    uint64_t id;
-    uint64_t eventId;
-    std::optional<std::string> logo;
-    std::optional<std::string> name;
-    std::vector<CITMPrice> prices;
-    std::vector<CITMSeatCategory> seatCategories;
-    std::optional<std::string> seatMapImage;
-    uint64_t start;
-    std::string venueCode;
-    bool operator==(const CITMPerformance&) const = default;
-};
-
-struct CITMEvent {
-    uint64_t id;
-    std::string name;
-    std::optional<std::string> description;
-    std::optional<std::string> logo;
-    std::vector<uint64_t> subTopicIds;
-    std::optional<std::string> subjectCode;
-    std::optional<std::string> subtitle;
-    std::vector<uint64_t> topicIds;
-    bool operator==(const CITMEvent&) const = default;
-};
-
-struct CitmCatalog {
-    std::map<std::string, CITMEvent> events;
-    std::vector<CITMPerformance> performances;
-    bool operator==(const CitmCatalog&) const = default;
-};
-
-// Type aliases
-using Event = CITMEvent;
-using Performance = CITMPerformance;
-using Price = CITMPrice;
-using SeatArea = CITMArea;
-using SeatCategoryInfo = CITMSeatCategory;
-
-#endif
@@ -1,79 +0,0 @@
-// nlohmann_citm_catalog_data.h
-#ifndef NLOHMANN_CITM_CATALOG_DATA_H
-#define NLOHMANN_CITM_CATALOG_DATA_H
-
-#include "citm_catalog_data.h"
-#include <nlohmann/json.hpp>
-#include <string>
-
-using json = nlohmann::json;
-
-// ---- CITMPrice ----
-inline void to_json(json &j, const CITMPrice &p) {
-    j = json{
-      {"amount", p.amount},
-      {"audienceSubCategoryId", p.audienceSubCategoryId},
-      {"seatCategoryId", p.seatCategoryId}
-    };
-}
-
-// ---- CITMArea ----
-inline void to_json(json &j, const CITMArea &a) {
-    j = json{
-      {"areaId", a.areaId},
-      {"blockIds", a.blockIds}
-    };
-}
-
-// ---- CITMSeatCategory ----
-inline void to_json(json &j, const CITMSeatCategory &s) {
-    j = json{
-      {"areas", s.areas},
-      {"seatCategoryId", s.seatCategoryId}
-    };
-}
-
-// ---- CITMPerformance ----
-inline void to_json(json &j, const CITMPerformance &p) {
-    j = json{
-      {"id", p.id},
-      {"eventId", p.eventId},
-      {"logo", p.logo},
-      {"name", p.name},
-      {"prices", p.prices},
-      {"seatCategories", p.seatCategories},
-      {"seatMapImage", p.seatMapImage},
-      {"start", p.start},
-      {"venueCode", p.venueCode}
-    };
-}
-
-// ---- CITMEvent ----
-inline void to_json(json &j, const CITMEvent &e) {
-    j = json{
-      {"id", e.id},
-      {"name", e.name},
-      {"description", e.description},
-      {"logo", e.logo},
-      {"subTopicIds", e.subTopicIds},
-      {"subjectCode", e.subjectCode},
-      {"subtitle", e.subtitle},
-      {"topicIds", e.topicIds}
-    };
-}
-
-// ---- CitmCatalog ----
-inline void to_json(json &j, const CitmCatalog &c) {
-    j = json{
-      {"events", c.events},
-      {"performances", c.performances}
-    };
-}
-
-// Serialization function
-inline std::string nlohmann_serialize(const CitmCatalog &catalog) {
-    json j = catalog;
-    return j.dump();
-}
-
-#endif // NLOHMANN_CITM_CATALOG_DATA_H
@@ -1,189 +0,0 @@
-#ifndef RAPIDJSON_CITM_CATALOG_DATA_H
-#define RAPIDJSON_CITM_CATALOG_DATA_H
-
-#include "citm_catalog_data.h"
-#include <rapidjson/document.h>
-#include <rapidjson/writer.h>
-#include <rapidjson/stringbuffer.h>
-#include <rapidjson/error/en.h>
-
-using namespace rapidjson;
-
-// RapidJSON deserialization for CITM Catalog data
-CitmCatalog rapidjson_deserialize_citm(const std::string& json_str) {
-    Document doc;
-    doc.Parse(json_str.c_str());
-
-    if (doc.HasParseError()) {
-        throw std::runtime_error("RapidJSON parse error");
-    }
-
-    CitmCatalog catalog;
-
-    // Parse events
-    if (doc.HasMember("events") && doc["events"].IsObject()) {
-        const Value& events = doc["events"];
-        for (auto it = events.MemberBegin(); it != events.MemberEnd(); ++it) {
-            Event event;
-            const Value& ev = it->value;
-
-            if (ev.HasMember("description") && ev["description"].IsString())
-                event.description = ev["description"].GetString();
-            if (ev.HasMember("id") && ev["id"].IsUint64())
-                event.id = ev["id"].GetUint64();
-            if (ev.HasMember("logo") && ev["logo"].IsString())
-                event.logo = ev["logo"].GetString();
-            if (ev.HasMember("name") && ev["name"].IsString())
-                event.name = ev["name"].GetString();
-            if (ev.HasMember("subjectCode") && ev["subjectCode"].IsString())
-                event.subjectCode = ev["subjectCode"].GetString();
-            if (ev.HasMember("subtitle") && ev["subtitle"].IsString())
-                event.subtitle = ev["subtitle"].GetString();
-
-            if (ev.HasMember("topicIds") && ev["topicIds"].IsArray()) {
-                const Value& topics = ev["topicIds"];
-                for (SizeType j = 0; j < topics.Size(); j++) {
-                    if (topics[j].IsUint64())
-                        event.topicIds.push_back(topics[j].GetUint64());
-                }
-            }
-
-            if (ev.HasMember("subTopicIds") && ev["subTopicIds"].IsArray()) {
-                const Value& subtopics = ev["subTopicIds"];
-                for (SizeType j = 0; j < subtopics.Size(); j++) {
-                    if (subtopics[j].IsUint64())
-                        event.subTopicIds.push_back(subtopics[j].GetUint64());
-                }
-            }
-
-            catalog.events[it->name.GetString()] = event;
-        }
-    }
-
-    // Parse performances
-    if (doc.HasMember("performances") && doc["performances"].IsArray()) {
-        const Value& performances = doc["performances"];
-        for (SizeType i = 0; i < performances.Size(); i++) {
-            Performance perf;
-            const Value& p = performances[i];
-
-            if (p.HasMember("id") && p["id"].IsUint64())
-                perf.id = p["id"].GetUint64();
-            if (p.HasMember("eventId") && p["eventId"].IsUint64())
-                perf.eventId = p["eventId"].GetUint64();
-            if (p.HasMember("start") && p["start"].IsUint64())
-                perf.start = p["start"].GetUint64();
-            if (p.HasMember("venueCode") && p["venueCode"].IsString())
-                perf.venueCode = p["venueCode"].GetString();
-            if (p.HasMember("name") && p["name"].IsString())
-                perf.name = p["name"].GetString();
-
-            catalog.performances.push_back(perf);
-        }
-    }
-
-    // Parse other string maps
-    auto parseStringMap = [&doc](const char* key, std::map<std::string, std::string>& target) {
-        if (doc.HasMember(key) && doc[key].IsObject()) {
-            const Value& obj = doc[key];
-            for (auto it = obj.MemberBegin(); it != obj.MemberEnd(); ++it) {
-                if (it->value.IsString()) {
-                    target[it->name.GetString()] = it->value.GetString();
-                }
-            }
-        }
-    };
-
-    return catalog;
-}
-
-// RapidJSON serialization for CITM Catalog data
-std::string rapidjson_serialize_citm(const CitmCatalog& catalog) {
-    Document doc;
-    doc.SetObject();
-    Document::AllocatorType& allocator = doc.GetAllocator();
-
-    // Serialize events
-    Value events_obj(kObjectType);
-    for (const auto& [key, event] : catalog.events) {
-        Value event_obj(kObjectType);
-
-        if (event.description) {
-            Value desc;
-            desc.SetString(event.description->c_str(), allocator);
-            event_obj.AddMember("description", desc, allocator);
-        }
-
-        event_obj.AddMember("id", event.id, allocator);
-
-        if (event.logo) {
-            Value logo;
-            logo.SetString(event.logo->c_str(), allocator);
-            event_obj.AddMember("logo", logo, allocator);
-        }
-
-        Value name;
-        name.SetString(event.name.c_str(), allocator);
-        event_obj.AddMember("name", name, allocator);
-
-        if (event.subjectCode) {
-            Value subject;
-            subject.SetString(event.subjectCode->c_str(), allocator);
-            event_obj.AddMember("subjectCode", subject, allocator);
-        }
-
-        if (event.subtitle) {
-            Value subtitle;
-            subtitle.SetString(event.subtitle->c_str(), allocator);
-            event_obj.AddMember("subtitle", subtitle, allocator);
-        }
-
-        Value topicIds(kArrayType);
-        for (uint64_t id : event.topicIds) {
-            topicIds.PushBack(id, allocator);
-        }
-        event_obj.AddMember("topicIds", topicIds, allocator);
-
-        Value subTopicIds(kArrayType);
-        for (uint64_t id : event.subTopicIds) {
-            subTopicIds.PushBack(id, allocator);
-        }
-        event_obj.AddMember("subTopicIds", subTopicIds, allocator);
-
-        Value key_val;
-        key_val.SetString(key.c_str(), allocator);
-        events_obj.AddMember(key_val, event_obj, allocator);
-    }
-    doc.AddMember("events", events_obj, allocator);
-
-    // Serialize performances
-    Value performances_array(kArrayType);
-    for (const auto& perf : catalog.performances) {
-        Value perf_obj(kObjectType);
-        perf_obj.AddMember("id", perf.id, allocator);
-        perf_obj.AddMember("eventId", perf.eventId, allocator);
-        perf_obj.AddMember("start", perf.start, allocator);
-
-        Value venue;
-        venue.SetString(perf.venueCode.c_str(), allocator);
-        perf_obj.AddMember("venueCode", venue, allocator);
-
-        if (perf.name) {
-            Value name;
-            name.SetString(perf.name->c_str(), allocator);
-            perf_obj.AddMember("name", name, allocator);
-        }
-
-
-        performances_array.PushBack(perf_obj, allocator);
-    }
-    doc.AddMember("performances", performances_array, allocator);
-
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    doc.Accept(writer);
-
-    return buffer.GetString();
-}
-
-#endif // RAPIDJSON_CITM_CATALOG_DATA_H
@@ -1,231 +0,0 @@
-#ifndef YYJSON_CITM_CATALOG_DATA_H
-#define YYJSON_CITM_CATALOG_DATA_H
-
-#include "citm_catalog_data.h"
-#include <yyjson.h>
-#include <string>
-#include <stdexcept>
-
-// yyjson deserialization for CITM Catalog data
-// Matches C++ CitmCatalog struct (only events + performances)
-CitmCatalog yyjson_deserialize_citm(const std::string &json_str) {
-    CitmCatalog catalog;
-
-    yyjson_doc *doc = yyjson_read(json_str.c_str(), json_str.size(), 0);
-    if (!doc) {
-        throw std::runtime_error("yyjson parse error");
-    }
-
-    yyjson_val *root = yyjson_doc_get_root(doc);
-    if (!root) {
-        yyjson_doc_free(doc);
-        return catalog;
-    }
-
-    // Parse events
-    yyjson_val *events_val = yyjson_obj_get(root, "events");
-    if (events_val && yyjson_is_obj(events_val)) {
-        size_t idx, max;
-        yyjson_val *key, *val;
-        yyjson_obj_foreach(events_val, idx, max, key, val) {
-            CITMEvent event;
-
-            yyjson_val *v;
-            v = yyjson_obj_get(val, "description");
-            if (v && yyjson_is_str(v)) event.description = yyjson_get_str(v);
-
-            v = yyjson_obj_get(val, "id");
-            if (v && yyjson_is_uint(v)) event.id = yyjson_get_uint(v);
-
-            v = yyjson_obj_get(val, "logo");
-            if (v && yyjson_is_str(v)) event.logo = yyjson_get_str(v);
-
-            v = yyjson_obj_get(val, "name");
-            if (v && yyjson_is_str(v)) event.name = yyjson_get_str(v);
-
-            v = yyjson_obj_get(val, "subjectCode");
-            if (v && yyjson_is_str(v)) event.subjectCode = yyjson_get_str(v);
-
-            v = yyjson_obj_get(val, "subtitle");
-            if (v && yyjson_is_str(v)) event.subtitle = yyjson_get_str(v);
-
-            // Parse topicIds array
-            v = yyjson_obj_get(val, "topicIds");
-            if (v && yyjson_is_arr(v)) {
-                size_t arr_idx, arr_max;
-                yyjson_val *arr_val;
-                yyjson_arr_foreach(v, arr_idx, arr_max, arr_val) {
-                    if (yyjson_is_uint(arr_val))
-                        event.topicIds.push_back(yyjson_get_uint(arr_val));
-                }
-            }
-
-            // Parse subTopicIds array
-            v = yyjson_obj_get(val, "subTopicIds");
-            if (v && yyjson_is_arr(v)) {
-                size_t arr_idx, arr_max;
-                yyjson_val *arr_val;
-                yyjson_arr_foreach(v, arr_idx, arr_max, arr_val) {
-                    if (yyjson_is_uint(arr_val))
-                        event.subTopicIds.push_back(yyjson_get_uint(arr_val));
-                }
-            }
-
-            if (yyjson_is_str(key))
-                catalog.events[yyjson_get_str(key)] = event;
-        }
-    }
-
-    // Parse performances (simplified - full parsing would need prices/seatCategories)
-    yyjson_val *performances_val = yyjson_obj_get(root, "performances");
-    if (performances_val && yyjson_is_arr(performances_val)) {
-        size_t idx, max;
-        yyjson_val *perf_val;
-        yyjson_arr_foreach(performances_val, idx, max, perf_val) {
-            CITMPerformance perf;
-
-            yyjson_val *v;
-            v = yyjson_obj_get(perf_val, "id");
-            if (v && yyjson_is_uint(v)) perf.id = yyjson_get_uint(v);
-
-            v = yyjson_obj_get(perf_val, "eventId");
-            if (v && yyjson_is_uint(v)) perf.eventId = yyjson_get_uint(v);
-
-            v = yyjson_obj_get(perf_val, "start");
-            if (v && yyjson_is_uint(v)) perf.start = yyjson_get_uint(v);
-
-            v = yyjson_obj_get(perf_val, "venueCode");
-            if (v && yyjson_is_str(v)) perf.venueCode = yyjson_get_str(v);
-
-            v = yyjson_obj_get(perf_val, "name");
-            if (v && yyjson_is_str(v)) perf.name = yyjson_get_str(v);
-
-            v = yyjson_obj_get(perf_val, "logo");
-            if (v && yyjson_is_str(v)) perf.logo = yyjson_get_str(v);
-
-            v = yyjson_obj_get(perf_val, "seatMapImage");
-            if (v && yyjson_is_str(v)) perf.seatMapImage = yyjson_get_str(v);
-
-            // Note: prices and seatCategories parsing omitted for brevity
-            // The serialization benchmark uses data loaded by simdjson
-
-            catalog.performances.push_back(perf);
-        }
-    }
-
-    yyjson_doc_free(doc);
-    return catalog;
-}
-
-// Helper to add optional string field
-static inline void yyjson_add_optional_str(yyjson_mut_doc *doc, yyjson_mut_val *obj,
-                                           const char *key, const std::optional<std::string> &val) {
-    if (val.has_value()) {
-        yyjson_mut_obj_add_str(doc, obj, key, val->c_str());
-    } else {
-        yyjson_mut_obj_add_null(doc, obj, key);
-    }
-}
-
-// yyjson serialization for CITM Catalog data
-// Matches C++ CitmCatalog struct exactly (only events + performances)
-std::string yyjson_serialize_citm(const CitmCatalog &catalog) {
-    yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
-    yyjson_mut_val *root = yyjson_mut_obj(doc);
-    yyjson_mut_doc_set_root(doc, root);
-
-    // Create events object
-    yyjson_mut_val *events_obj = yyjson_mut_obj(doc);
-    for (const auto& [key, event] : catalog.events) {
-        yyjson_mut_val *event_obj = yyjson_mut_obj(doc);
-
-        yyjson_add_optional_str(doc, event_obj, "description", event.description);
-        yyjson_mut_obj_add_uint(doc, event_obj, "id", event.id);
-        yyjson_add_optional_str(doc, event_obj, "logo", event.logo);
-        // name is not optional in CITMEvent
-        yyjson_mut_obj_add_str(doc, event_obj, "name", event.name.c_str());
-
-        // Add subTopicIds array
-        yyjson_mut_val *subtopic_ids = yyjson_mut_arr(doc);
-        for (uint64_t id : event.subTopicIds) {
-            yyjson_mut_arr_add_uint(doc, subtopic_ids, id);
-        }
-        yyjson_mut_obj_add_val(doc, event_obj, "subTopicIds", subtopic_ids);
-
-        yyjson_add_optional_str(doc, event_obj, "subjectCode", event.subjectCode);
-        yyjson_add_optional_str(doc, event_obj, "subtitle", event.subtitle);
-
-        // Add topicIds array
-        yyjson_mut_val *topic_ids = yyjson_mut_arr(doc);
-        for (uint64_t id : event.topicIds) {
-            yyjson_mut_arr_add_uint(doc, topic_ids, id);
-        }
-        yyjson_mut_obj_add_val(doc, event_obj, "topicIds", topic_ids);
-
-        yyjson_mut_obj_add_val(doc, events_obj, key.c_str(), event_obj);
-    }
-    yyjson_mut_obj_add_val(doc, root, "events", events_obj);
-
-    // Create performances array
-    yyjson_mut_val *performances_array = yyjson_mut_arr(doc);
-    for (const auto& perf : catalog.performances) {
-        yyjson_mut_val *perf_obj = yyjson_mut_obj(doc);
-
-        yyjson_mut_obj_add_uint(doc, perf_obj, "eventId", perf.eventId);
-        yyjson_mut_obj_add_uint(doc, perf_obj, "id", perf.id);
-        yyjson_add_optional_str(doc, perf_obj, "logo", perf.logo);
-        yyjson_add_optional_str(doc, perf_obj, "name", perf.name);
-
-        // Add prices array
-        yyjson_mut_val *prices_array = yyjson_mut_arr(doc);
-        for (const auto& price : perf.prices) {
-            yyjson_mut_val *price_obj = yyjson_mut_obj(doc);
-            yyjson_mut_obj_add_uint(doc, price_obj, "amount", price.amount);
-            yyjson_mut_obj_add_uint(doc, price_obj, "audienceSubCategoryId", price.audienceSubCategoryId);
-            yyjson_mut_obj_add_uint(doc, price_obj, "seatCategoryId", price.seatCategoryId);
-            yyjson_mut_arr_append(prices_array, price_obj);
-        }
-        yyjson_mut_obj_add_val(doc, perf_obj, "prices", prices_array);
-
-        // Add seatCategories array
-        yyjson_mut_val *seat_cats_array = yyjson_mut_arr(doc);
-        for (const auto& seatCat : perf.seatCategories) {
-            yyjson_mut_val *seat_cat_obj = yyjson_mut_obj(doc);
-
-            // Add areas array
-            yyjson_mut_val *areas_array = yyjson_mut_arr(doc);
-            for (const auto& area : seatCat.areas) {
-                yyjson_mut_val *area_obj = yyjson_mut_obj(doc);
-                yyjson_mut_obj_add_uint(doc, area_obj, "areaId", area.areaId);
-
-                yyjson_mut_val *block_ids = yyjson_mut_arr(doc);
-                for (uint64_t blockId : area.blockIds) {
-                    yyjson_mut_arr_add_uint(doc, block_ids, blockId);
-                }
-                yyjson_mut_obj_add_val(doc, area_obj, "blockIds", block_ids);
-                yyjson_mut_arr_append(areas_array, area_obj);
-            }
-            yyjson_mut_obj_add_val(doc, seat_cat_obj, "areas", areas_array);
-            yyjson_mut_obj_add_uint(doc, seat_cat_obj, "seatCategoryId", seatCat.seatCategoryId);
-            yyjson_mut_arr_append(seat_cats_array, seat_cat_obj);
-        }
-        yyjson_mut_obj_add_val(doc, perf_obj, "seatCategories", seat_cats_array);
-
-        yyjson_add_optional_str(doc, perf_obj, "seatMapImage", perf.seatMapImage);
-        yyjson_mut_obj_add_uint(doc, perf_obj, "start", perf.start);
-        yyjson_mut_obj_add_str(doc, perf_obj, "venueCode", perf.venueCode.c_str());
-
-        yyjson_mut_arr_append(performances_array, perf_obj);
-    }
-    yyjson_mut_obj_add_val(doc, root, "performances", performances_array);
-
-    // Write to string
-    char *json_output = yyjson_mut_write(doc, 0, NULL);
-    std::string result(json_output);
-    free(json_output);
-    yyjson_mut_doc_free(doc);
-
-    return result;
-}
-
-#endif // YYJSON_CITM_CATALOG_DATA_H
@@ -1,103 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "itoa"
-version = "1.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
-
-[[package]]
-name = "libc"
-version = "0.2.158"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
-
-[[package]]
-name = "memchr"
-version = "2.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "ryu"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
-
-[[package]]
-name = "serde"
-version = "1.0.209"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde-benchmark"
-version = "0.1.0"
-dependencies = [
- "libc",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.209"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.127"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
-dependencies = [
- "itoa",
- "memchr",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.76"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
@@ -1,17 +0,0 @@
-[package]
-name = "serde-benchmark"
-version = "0.1.0"
-
-[lib]
-path = "lib.rs"
-crate-type = ["cdylib"]
-
-[dependencies]
-serde = { version = "1.0", features = ["derive"] }
-libc = "0.2"
-serde_json = "1.0"
-
-[profile.release]
-opt-level = 3
-debug = false
-lto = true
@@ -1,18 +0,0 @@
-## Rust Serde FFI
-
-This folder includes FFI bindings for rust/serde.
-
-### Links
-
- https://github.com/eqrion/cbindgen/blob/master/docs.md
- https://gist.github.com/zbraniecki/b251714d77ffebbc73c03447f2b2c69f
- https://michael-f-bryan.github.io/rust-ffi-guide/setting_up.html
-
-### Building
-
- Generating cbindgen output
-  - Install dependencies with `brew install cbindgen` or `apt-get install cbindgen` or `cargo install cbindgen` or the equivalent: we used `cargo install --version 0.23.0 cbindgen`.
-  - Go to the directory where this README.md file is located
-  - Generate with `cbindgen --config cbindgen.toml --crate serde-benchmark --output serde_benchmark.h`
- Building
-  - Run with `cargo build --release`
@@ -1,12 +0,0 @@
-autogen_warning = "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */"
-include_version = true
-braces = "SameLine"
-line_length = 100
-tab_width = 2
-language = "C++"
-namespaces = ["serde_benchmark"]
-include_guard = "serde_benchmark_ffi_h"
-
-[parse]
-parse_deps = true
-include = ["serde_json", "serde"]
@@ -1,351 +0,0 @@
-extern crate serde;
-extern crate serde_json;
-extern crate libc;
-
-use libc::{c_char, size_t};
-use serde::{Serialize, Deserialize};
-use std::{collections::HashMap, ffi::CString, ptr, slice};
-
-//==============================================================================
-// Twitter Benchmark Structures
-// These match the C++ TwitterData structures exactly
-//==============================================================================
-
-#[derive(Serialize, Deserialize)]
-pub struct User {
-    id: u64,
-    name: String,
-    screen_name: String,
-    location: String,
-    description: String,
-    verified: bool,
-    followers_count: u64,
-    friends_count: u64,
-    statuses_count: u64,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Status {
-    created_at: String,
-    id: u64,
-    text: String,
-    user: User,
-    retweet_count: u64,
-    favorite_count: u64,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct TwitterData {
-    statuses: Vec<Status>,
-}
-static mut TWITTER_DATA: *mut TwitterData = std::ptr::null_mut();
-
-#[no_mangle]
-pub unsafe extern "C" fn twitter_from_str(raw_input: *const c_char, raw_input_length: size_t) -> *mut TwitterData {
-    let input = std::str::from_utf8_unchecked(slice::from_raw_parts(raw_input as *const u8, raw_input_length));
-    match serde_json::from_str(&input) {
-        Ok(result) => Box::into_raw(Box::new(result)),
-        Err(_) => std::ptr::null_mut(),
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn set_twitter_data(raw: *mut TwitterData) {
-    TWITTER_DATA = raw;
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn serialize_twitter_to_string() -> usize {
-    if TWITTER_DATA.is_null() {
-        return 0;
-    }
-    let data = &*TWITTER_DATA;
-    serde_json::to_string(data).unwrap().len()
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn free_twitter(raw: *mut TwitterData) {
-    if raw.is_null() {
-        return;
-    }
-    drop(Box::from_raw(raw))
-}
-
-#[no_mangle]
-pub unsafe extern fn free_string(ptr: *const c_char) {
-    let _ = std::ffi::CString::from_raw(ptr as *mut _);
-}
-
-//==============================================================================
-// CITM Catalog Benchmark Structures
-// These match the C++ CitmCatalog structures EXACTLY for fair comparison
-//==============================================================================
-
-/// Matches C++ CITMPrice struct exactly
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct CITMPrice {
-    pub amount: u64,
-    #[serde(rename = "audienceSubCategoryId")]
-    pub audience_sub_category_id: u64,
-    #[serde(rename = "seatCategoryId")]
-    pub seat_category_id: u64,
-}
-
-/// Matches C++ CITMArea struct exactly
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct CITMArea {
-    #[serde(rename = "areaId")]
-    pub area_id: u64,
-    #[serde(rename = "blockIds")]
-    pub block_ids: Vec<u64>,
-}
-
-/// Matches C++ CITMSeatCategory struct exactly
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct CITMSeatCategory {
-    pub areas: Vec<CITMArea>,
-    #[serde(rename = "seatCategoryId")]
-    pub seat_category_id: u64,
-}
-
-/// Matches C++ CITMPerformance struct exactly
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct CITMPerformance {
-    pub id: u64,
-    #[serde(rename = "eventId")]
-    pub event_id: u64,
-    #[serde(default)]
-    pub logo: Option<String>,
-    #[serde(default)]
-    pub name: Option<String>,
-    pub prices: Vec<CITMPrice>,
-    #[serde(rename = "seatCategories")]
-    pub seat_categories: Vec<CITMSeatCategory>,
-    #[serde(default)]
-    #[serde(rename = "seatMapImage")]
-    pub seat_map_image: Option<String>,
-    pub start: u64,
-    #[serde(rename = "venueCode")]
-    pub venue_code: String,
-}
-
-/// Matches C++ CITMEvent struct exactly
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct CITMEvent {
-    pub id: u64,
-    #[serde(default)]
-    pub name: Option<String>,
-    #[serde(default)]
-    pub description: Option<String>,
-    #[serde(default)]
-    pub logo: Option<String>,
-    #[serde(default)]
-    #[serde(rename = "subTopicIds")]
-    pub sub_topic_ids: Vec<u64>,
-    #[serde(default)]
-    #[serde(rename = "subjectCode")]
-    pub subject_code: Option<String>,
-    #[serde(default)]
-    pub subtitle: Option<String>,
-    #[serde(default)]
-    #[serde(rename = "topicIds")]
-    pub topic_ids: Vec<u64>,
-}
-
-/// Matches C++ CitmCatalog struct exactly - ONLY events and performances
-/// This is the key fix: we serialize only what C++ serializes
-#[derive(Serialize, Deserialize, Debug)]
-pub struct CitmCatalog {
-    pub events: HashMap<String, CITMEvent>,
-    pub performances: Vec<CITMPerformance>,
-}
-
-static mut CITM_DATA: *mut CitmCatalog = std::ptr::null_mut();
-
-/// Creates a CitmCatalog from a JSON string (UTF-8 encoded).
-/// Only extracts events and performances to match C++ behavior.
-#[no_mangle]
-pub unsafe extern "C" fn citm_from_str(
-    raw_input: *const c_char,
-    raw_input_length: usize
-) -> *mut CitmCatalog {
-    if raw_input.is_null() {
-        eprintln!("Error: Input pointer is null");
-        return ptr::null_mut();
-    }
-
-    let bytes = slice::from_raw_parts(raw_input as *const u8, raw_input_length);
-    let input_str = match std::str::from_utf8(bytes) {
-        Ok(s) => s,
-        Err(e) => {
-            eprintln!("Error: Invalid UTF-8 string: {}", e);
-            return ptr::null_mut();
-        }
-    };
-
-    // Parse the full JSON to extract only events and performances
-    match serde_json::from_str::<serde_json::Value>(input_str) {
-        Ok(full_json) => {
-            // Extract only the fields we need (matching C++ behavior)
-            let events: HashMap<String, CITMEvent> = full_json.get("events")
-                .and_then(|v| serde_json::from_value(v.clone()).ok())
-                .unwrap_or_default();
-
-            let performances: Vec<CITMPerformance> = full_json.get("performances")
-                .and_then(|v| serde_json::from_value(v.clone()).ok())
-                .unwrap_or_default();
-
-            let catalog = CitmCatalog { events, performances };
-            Box::into_raw(Box::new(catalog))
-        },
-        Err(e) => {
-            eprintln!("Error deserializing JSON: {}", e);
-            ptr::null_mut()
-        }
-    }
-}
-
-/// Serializes a CitmCatalog into a JSON string (UTF-8).
-#[no_mangle]
-pub unsafe extern "C" fn set_citm_data(raw: *mut CitmCatalog) {
-    CITM_DATA = raw;
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn serialize_citm_to_string() -> usize {
-    if CITM_DATA.is_null() {
-        return 0;
-    }
-    let data = &*CITM_DATA;
-    return serde_json::to_string(data).unwrap().len();
-}
-
-/// Frees the CitmCatalog pointer.
-#[no_mangle]
-pub unsafe extern "C" fn free_citm(raw_catalog: *mut CitmCatalog) {
-    if !raw_catalog.is_null() {
-        drop(Box::from_raw(raw_catalog));
-    }
-}
-
-#[no_mangle]
-pub extern "C" fn free_str(ptr: *mut c_char) {
-    if !ptr.is_null() {
-        unsafe {
-            let _ = CString::from_raw(ptr);
-        }
-    }
-}
-
-//==============================================================================
-// FFI Overhead Measurement Functions
-// These allow measuring the actual FFI overhead vs pure Rust serialization
-//==============================================================================
-
-/// Result structure for FFI overhead measurement
-#[repr(C)]
-pub struct FfiOverheadResult {
-    /// Time in nanoseconds for pure serde_json::to_string() (no FFI overhead)
-    pub pure_serde_ns: u64,
-    /// Time in nanoseconds for serde + CString conversion
-    pub serde_plus_cstring_ns: u64,
-    /// Number of iterations performed
-    pub iterations: u64,
-    /// Output size in bytes (for verification)
-    pub output_size: u64,
-}
-
-/// Prevents compiler from optimizing away the value
-/// Works on stable Rust (unlike std::hint::black_box which is unstable)
-#[inline(never)]
-fn black_box<T>(dummy: T) -> T {
-    unsafe {
-        let ret = std::ptr::read_volatile(&dummy);
-        std::mem::forget(dummy);
-        ret
-    }
-}
-
-/// Measures FFI overhead for Twitter serialization.
-/// Performs `iterations` serializations entirely in Rust and returns timing data.
-/// This allows comparing against per-call FFI overhead.
-#[no_mangle]
-pub unsafe extern "C" fn measure_twitter_ffi_overhead(
-    raw: *mut TwitterData,
-    iterations: u64
-) -> FfiOverheadResult {
-    use std::time::Instant;
-
-    let twitter_data = &*raw;
-    let output_size: u64;
-
-    // Warm-up run
-    let warmup = serde_json::to_string(&twitter_data).unwrap();
-    output_size = warmup.len() as u64;
-
-    // Measure pure serde_json::to_string() - no CString conversion
-    let start_pure = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&twitter_data).unwrap();
-        // Prevent optimization from eliminating the work
-        black_box(&serialized);
-    }
-    let pure_serde_ns = start_pure.elapsed().as_nanos() as u64;
-
-    // Measure serde + CString conversion (but not FFI return)
-    let start_cstring = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&twitter_data).unwrap();
-        let cstring = CString::new(serialized).unwrap();
-        // Prevent optimization from eliminating the work
-        black_box(&cstring);
-    }
-    let serde_plus_cstring_ns = start_cstring.elapsed().as_nanos() as u64;
-
-    FfiOverheadResult {
-        pure_serde_ns,
-        serde_plus_cstring_ns,
-        iterations,
-        output_size,
-    }
-}
-
-/// Measures FFI overhead for CITM serialization.
-#[no_mangle]
-pub unsafe extern "C" fn measure_citm_ffi_overhead(
-    raw: *mut CitmCatalog,
-    iterations: u64
-) -> FfiOverheadResult {
-    use std::time::Instant;
-
-    let catalog = &*raw;
-    let output_size: u64;
-
-    // Warm-up run
-    let warmup = serde_json::to_string(&catalog).unwrap();
-    output_size = warmup.len() as u64;
-
-    // Measure pure serde_json::to_string() - no CString conversion
-    let start_pure = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&catalog).unwrap();
-        black_box(&serialized);
-    }
-    let pure_serde_ns = start_pure.elapsed().as_nanos() as u64;
-
-    // Measure serde + CString conversion
-    let start_cstring = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&catalog).unwrap();
-        let cstring = CString::new(serialized).unwrap();
-        black_box(&cstring);
-    }
-    let serde_plus_cstring_ns = start_cstring.elapsed().as_nanos() as u64;
-
-    FfiOverheadResult {
-        pure_serde_ns,
-        serde_plus_cstring_ns,
-        iterations,
-        output_size,
-    }
-}
@@ -1,68 +0,0 @@
-#ifndef serde_benchmark_ffi_h
-#define serde_benchmark_ffi_h
-
-/* Generated with cbindgen:0.28.0 */
-
-/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
-/* Note: FfiOverheadResult and measurement functions added manually */
-
-#include <cstdarg>
-#include <cstdint>
-#include <cstdlib>
-#include <ostream>
-#include <new>
-
-namespace serde_benchmark {
-
-struct CitmCatalog;
-
-struct TwitterData;
-
-/// Result structure for FFI overhead measurement
-struct FfiOverheadResult {
-    /// Time in nanoseconds for pure serde_json::to_string() (no FFI overhead)
-    uint64_t pure_serde_ns;
-    /// Time in nanoseconds for serde + CString conversion
-    uint64_t serde_plus_cstring_ns;
-    /// Number of iterations performed
-    uint64_t iterations;
-    /// Output size in bytes (for verification)
-    uint64_t output_size;
-};
-
-extern "C" {
-
-TwitterData *twitter_from_str(const char *raw_input, size_t raw_input_length);
-
-void set_twitter_data(TwitterData *raw);
-
-size_t serialize_twitter_to_string();
-
-void free_twitter(TwitterData *raw);
-
-void free_string(const char *ptr);
-
-/// Creates a CitmCatalog from a JSON string (UTF-8 encoded).
-CitmCatalog *citm_from_str(const char *raw_input, uintptr_t raw_input_length);
-
-void set_citm_data(CitmCatalog *raw);
-
-size_t serialize_citm_to_string();
-
-/// Frees the CitmCatalog pointer.
-void free_citm(CitmCatalog *raw_catalog);
-
-void free_str(char *ptr);
-
-/// Measures FFI overhead for Twitter serialization.
-/// Performs `iterations` serializations entirely in Rust and returns timing data.
-FfiOverheadResult measure_twitter_ffi_overhead(TwitterData *raw, uint64_t iterations);
-
-/// Measures FFI overhead for CITM serialization.
-FfiOverheadResult measure_citm_ffi_overhead(CitmCatalog *raw, uint64_t iterations);
-
-}  // extern "C"
-
-}  // namespace serde_benchmark
-
-#endif  // serde_benchmark_ffi_h
@@ -1,31 +0,0 @@
-use std::fs;
-
-// Include the lib.rs content directly
-include!("../lib.rs");
-
-fn main() {
-    // Read the Twitter JSON file
-    let json_str = fs::read_to_string("/Users/random_person/Desktop/simdjson/build/jsonexamples/twitter.json")
-        .expect("Failed to read file");
-
-    // Parse it
-    let data: TwitterData = serde_json::from_str(&json_str)
-        .expect("Failed to parse JSON");
-
-    // Serialize it back
-    let output = serde_json::to_string(&data)
-        .expect("Failed to serialize");
-
-    // Write to file for comparison
-    fs::write("rust_output.json", &output)
-        .expect("Failed to write output");
-
-    println!("Output size: {} bytes", output.len());
-    println!("Written to rust_output.json");
-
-    // Also write pretty version for easier inspection
-    let pretty = serde_json::to_string_pretty(&data)
-        .expect("Failed to serialize pretty");
-    fs::write("rust_output_pretty.json", &pretty)
-        .expect("Failed to write pretty output");
-}
@@ -1,36 +0,0 @@
-use std::fs;
-
-// Import from the parent lib.rs
-include!("../lib.rs");
-
-fn main() {
-    // Read the Twitter JSON file
-    let json_str = fs::read_to_string("/Users/random_person/Desktop/simdjson/build/jsonexamples/twitter.json")
-        .expect("Failed to read file");
-
-    // Parse it
-    let data: TwitterData = serde_json::from_str(&json_str)
-        .expect("Failed to parse JSON");
-
-    // Serialize it back (compact)
-    let output = serde_json::to_vec(&data)
-        .expect("Failed to serialize");
-    
-    let output_str = String::from_utf8(output.clone()).unwrap();
-
-    // Write to file for comparison
-    fs::write("rust_output_test.json", &output)
-        .expect("Failed to write output");
-
-    println!("Output size: {} bytes", output.len());
-    
-    // Count statuses
-    println!("Number of statuses: {}", data.statuses.len());
-    
-    // Check what fields are in the first status
-    if let Some(first) = data.statuses.first() {
-        // Let's serialize just the first status to see what fields are included
-        let first_json = serde_json::to_string_pretty(first).unwrap();
-        println!("First status (pretty):\n{}", first_json);
-    }
-}
@@ -1,32 +0,0 @@
-
-# Add executable targets
-add_executable(benchmark_serialization_twitter benchmark_serialization_twitter.cpp)
-add_executable(benchmark_parsing_twitter benchmark_parsing_twitter.cpp)
-
- if(TARGET serde-benchmark)
-    message(STATUS "serde-benchmark target was created. Linking benchmarks and serde-benchmark.")
-    target_link_libraries(benchmark_serialization_twitter PRIVATE serde-benchmark)
-    target_link_libraries(benchmark_parsing_twitter PRIVATE serde-benchmark)
-    target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
-    target_compile_definitions(benchmark_parsing_twitter PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
-endif()
-target_link_libraries(benchmark_serialization_twitter PRIVATE simdjson::simdjson nlohmann_json)
-target_link_libraries(benchmark_serialization_twitter PRIVATE reflectcpp)
-target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_BENCH_CPP_REFLECT=1)
-
-target_link_libraries(benchmark_parsing_twitter PRIVATE simdjson::simdjson nlohmann_json)
-
-if(TARGET rapidjson)
-    target_link_libraries(benchmark_parsing_twitter PRIVATE rapidjson)
-    target_compile_definitions(benchmark_parsing_twitter PRIVATE SIMDJSON_COMPETITION_RAPIDJSON)
-endif()
-
-if(TARGET yyjson)
-    target_link_libraries(benchmark_parsing_twitter PRIVATE yyjson)
-    target_compile_definitions(benchmark_parsing_twitter PRIVATE SIMDJSON_COMPETITION_YYJSON)
-    target_link_libraries(benchmark_serialization_twitter PRIVATE yyjson)
-    target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_COMPETITION_YYJSON)
-endif()
-
-target_compile_definitions(benchmark_serialization_twitter PRIVATE JSON_FILE="${EXAMPLE_JSON}")
-target_compile_definitions(benchmark_parsing_twitter PRIVATE JSON_FILE="${EXAMPLE_JSON}")
@@ -1,232 +0,0 @@
-#include <cassert>
-#include <cstdlib>
-#include <ctime>
-#include <format>
-#include <fstream>
-#include <iostream>
-#include <nlohmann/json.hpp>
-#include <simdjson.h>
-#include <string>
-#include "twitter_data.h"
-#include "nlohmann_twitter_data.h"
-#include "../benchmark_utils/benchmark_helper.h"
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-#include "rapidjson_twitter_data.h"
-#endif
-#ifdef SIMDJSON_COMPETITION_YYJSON
-#include "yyjson_twitter_data.h"
-#endif
-
-#ifdef SIMDJSON_RUST_VERSION
-#include "../serde-benchmark/serde_benchmark.h"
-
-void bench_rust_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_rust_parsing",
-               bench([&json_str, &result]() {
-                 serde_benchmark::TwitterData *td = serde_benchmark::twitter_from_str(json_str.c_str(), json_str.size());
-                 result = (td != nullptr);
-                 if (td) {
-                   serde_benchmark::free_twitter(td);
-                 }
-                 if (!result) {
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-// OPTIMIZED VERSION: Reuses parser across iterations
-template <class T>
-void bench_simdjson_static_reflection_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  // Pre-allocate padded buffer outside the benchmark loop
-  simdjson::padded_string padded = simdjson::padded_string(json_str);
-
-  // CRITICAL: Create parser OUTSIDE the loop for reuse
-  simdjson::ondemand::parser parser;
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_simdjson_static_reflection_parsing",
-               bench([&padded, &result, &parser]() {
-                 // Reuse the same parser instance
-                 simdjson::ondemand::document doc;
-                 if(parser.iterate(padded).get(doc)) {
-                   result = false;
-                   return;
-                 }
-                 T my_struct;
-                 if(doc.get<T>().get(my_struct)) {
-                   result = false;
-                 }
-                 if (!result) {
-                   printf("parse error\n");
-                 }
-               }));
-}
-
-#if SIMDJSON_STATIC_REFLECTION
-template <class T>
-void bench_simdjson_from_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  // Pre-allocate padded buffer outside the benchmark loop
-  simdjson::padded_string padded = simdjson::padded_string(json_str);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_simdjson_from_parsing",
-               bench([&padded, &result]() {
-                 T my_struct;
-                 auto err = simdjson::from(padded).get(my_struct);
-                  if (err) {
-                    result = false;
-                    printf("parse error: %s\n", simdjson::error_message(err));
-                    return;
-                  }
-               }));
-}
-#endif
-
- void bench_nlohmann_parsing(const std::string &json_str) {
-   size_t input_volume = json_str.size();
-   printf("# input volume: %zu bytes\n", input_volume);
-
-   volatile bool result = true;
-   pretty_print(1, input_volume, "bench_nlohmann_parsing",
-                bench([&json_str, &result]() {
-                  try {
-                    TwitterData data = nlohmann_deserialize(json_str);
-                    result = true;
-                  } catch (...) {
-                    result = false;
-                    printf("parse error\n");
-                  }
-                }));
-}
-
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-void bench_rapidjson_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_rapidjson_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   TwitterData data = rapidjson_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-#ifdef SIMDJSON_COMPETITION_YYJSON
-void bench_yyjson_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_yyjson_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   TwitterData data = yyjson_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-std::string read_file(std::string filename) {
-  printf("# Reading file %s\n", filename.c_str());
-  constexpr size_t read_size = 4096;
-  auto stream = std::ifstream(filename.c_str());
-  stream.exceptions(std::ios_base::badbit);
-  std::string out;
-  std::string buf(read_size, '\0');
-  while (stream.read(&buf[0], read_size)) {
-    out.append(buf, 0, size_t(stream.gcount()));
-  }
-  out.append(buf, 0, size_t(stream.gcount()));
-  return out;
-}
-
-// Function to check if benchmark name matches any of the comma-separated filters
-bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  if (filter.empty()) return true;
-
-  // Split filter by comma
-  size_t start = 0;
-  size_t end = filter.find(',');
-  while (end != std::string::npos) {
-    std::string token = filter.substr(start, end - start);
-    if (benchmark_name.find(token) != std::string::npos) {
-      return true;
-    }
-    start = end + 1;
-    end = filter.find(',', start);
-  }
-  // Check last token
-  std::string token = filter.substr(start);
-  return benchmark_name.find(token) != std::string::npos;
-}
-
-int main(int argc, char* argv[]) {
-  std::string filter;
-
-  // Parse command-line arguments
-  for (int i = 1; i < argc; ++i) {
-      if (strcmp(argv[i], "-f") == 0 || strcmp(argv[i], "--filter") == 0) {
-          if (i + 1 < argc) {
-              filter = argv[++i];
-          } else {
-              std::cerr << "Error: -f/--filter requires an argument" << std::endl;
-              return EXIT_FAILURE;
-          }
-      }
-  }
-
-  // Load the JSON data
-  std::string json_str = read_file(JSON_FILE);
-
-  // Benchmarking the parsing
-  if (matches_filter("nlohmann", filter)) {
-    bench_nlohmann_parsing(json_str);
-  }
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-  if (matches_filter("rapidjson", filter)) {
-    bench_rapidjson_parsing(json_str);
-  }
-#endif
-#ifdef SIMDJSON_COMPETITION_YYJSON
-  if (matches_filter("yyjson", filter)) {
-    bench_yyjson_parsing(json_str);
-  }
-#endif
-  if (matches_filter("simdjson_static_reflection", filter)) {
-    bench_simdjson_static_reflection_parsing<TwitterData>(json_str);
-  }
-#if SIMDJSON_STATIC_REFLECTION
-  if (matches_filter("simdjson_from", filter)) {
-    bench_simdjson_from_parsing<TwitterData>(json_str);
-  }
-#endif
-#ifdef SIMDJSON_RUST_VERSION
-  if (matches_filter("rust", filter)) {
-    printf("# Note: Rust/Serde parsing test\n");
-    bench_rust_parsing(json_str);
-  }
-#endif
-  return EXIT_SUCCESS;
-}
@@ -1,315 +0,0 @@
-#include <cassert>
-#include <chrono>
-#include <cstdlib>
-#include <ctime>
-#include <format>
-#include <fstream>
-#include <iostream>
-#include <nlohmann/json.hpp>
-#include <simdjson.h>
-#include <string>
-#include "twitter_data.h"
-#include "nlohmann_twitter_data.h"
-#include "../benchmark_utils/benchmark_helper.h"
-#ifdef SIMDJSON_COMPETITION_YYJSON
-#include "yyjson_twitter_data.h"
-#endif
-#if SIMDJSON_BENCH_CPP_REFLECT
-#include <rfl.hpp>
-#include <rfl/json.hpp>
-void bench_reflect_cpp(TwitterData &data) {
-  std::string output = rfl::json::write(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_reflect_cpp",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = rfl::json::write(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif // SIMDJSON_BENCH_CPP_REFLECT
-
-#ifdef SIMDJSON_RUST_VERSION
-#include "../serde-benchmark/serde_benchmark.h"
-
-
-void bench_rust(serde_benchmark::TwitterData *data) {
-  serde_benchmark::set_twitter_data(data);
-  size_t output_volume = serde_benchmark::serialize_twitter_to_string();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_rust",
-               bench([&measured_volume, &output_volume]() {
-                 measured_volume = serde_benchmark::serialize_twitter_to_string();
-               }));
-}
-#endif
-
-// Fair allocation variant: allocates fresh buffer each iteration (matches other libraries)
-template <class T> void bench_simdjson_static_reflection(T &data) {
-  // First run to determine expected size
-  simdjson::builder::string_builder sb_init;
-  simdjson::builder::append(sb_init, data);
-  std::string_view p_init;
-  if(sb_init.view().get(p_init)) {
-    std::cerr << "Error!" << std::endl;
-  }
-  size_t output_volume = p_init.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
-               bench([&data, &measured_volume, &output_volume]() {
-                 // Fresh allocation each iteration - fair comparison
-                 simdjson::builder::string_builder sb;
-                 simdjson::builder::append(sb, data);
-                 std::string_view p;
-                 if(sb.view().get(p)) {
-                   std::cerr << "Error!" << std::endl;
-                 }
-                 measured_volume = sb.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-// Optimized variant: reuses buffer across iterations (shows API potential)
-template <class T> void bench_simdjson_static_reflection_reuse(T &data) {
-  simdjson::builder::string_builder sb;
-  simdjson::builder::append(sb, data);
-  std::string_view p;
-  if(sb.view().get(p)) {
-    std::cerr << "Error!" << std::endl;
-  }
-  size_t output_volume = p.size();
-  sb.clear();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_reuse_buffer",
-               bench([&data, &measured_volume, &output_volume, &sb]() {
-                 sb.clear();
-                 simdjson::builder::append(sb, data);
-                 std::string_view p;
-                 if(sb.view().get(p)) {
-                   std::cerr << "Error!" << std::endl;
-                 }
-                 measured_volume = sb.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-#if SIMDJSON_STATIC_REFLECTION
-// Fair allocation variant: allocates fresh string each iteration
-template <class T> void bench_simdjson_to(T &data) {
-  // First run to determine size
-  std::string output_init;
-  if (simdjson::error_code err = simdjson::builder::to_json(data, output_init); err) {
-    std::cerr << "Error in to_json initialization!" << simdjson::error_message(err) << std::endl;
-    return;
-  }
-  size_t output_volume = output_init.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_to",
-               bench([&data, &measured_volume, &output_volume]() {
-                 // Fresh allocation each iteration - fair comparison
-                 std::string output;
-                 if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
-                   std::cerr << "Error in to_json!" << simdjson::error_message(err) << std::endl;
-                   return;
-                 }
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-// Optimized variant: reuses pre-allocated string
-template <class T> void bench_simdjson_to_reuse(T &data) {
-  std::string output;
-  if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
-    std::cerr << "Error in to_json initialization!" << simdjson::error_message(err) << std::endl;
-    return;
-  }
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  // Pre-allocate string with sufficient capacity to avoid reallocation
-  output.reserve(output_volume * 2);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_to_reuse",
-               bench([&data, &measured_volume, &output_volume, &output]() {
-                 // Reuse the pre-allocated string - avoids allocation
-                 if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
-                   std::cerr << "Error in to_json!" << simdjson::error_message(err) << std::endl;
-                   return;
-                 }
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif
-
-void bench_nlohmann(TwitterData &data) {
-  std::string output = nlohmann_serialize(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_nlohmann",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = nlohmann_serialize(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-#ifdef SIMDJSON_COMPETITION_YYJSON
-void bench_yyjson(TwitterData &data) {
-  std::string output = yyjson_serialize(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_yyjson",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = yyjson_serialize(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif
-
-size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp) {
-  ((std::string *)userp)->append((char *)contents, size * nmemb);
-  return size * nmemb;
-}
-
-simdjson::padded_string read_file(std::string filename) {
-  printf("# Reading file %s\n", filename.c_str());
-  constexpr size_t read_size = 4096;
-  auto stream = std::ifstream(filename.c_str());
-  stream.exceptions(std::ios_base::badbit);
-  simdjson::padded_string_builder builder;
-  std::string buf(read_size, '\0');
-  while (stream.read(&buf[0], read_size)) {
-    builder.append(buf.data(), size_t(stream.gcount()));
-  }
-  builder.append(buf.data(), size_t(stream.gcount()));
-  return builder.convert();
-}
-
-// Function to check if benchmark name matches any of the comma-separated filters
-bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  if (filter.empty()) return true;
-
-  // Split filter by comma
-  size_t start = 0;
-  size_t end = filter.find(',');
-  while (end != std::string::npos) {
-    std::string token = filter.substr(start, end - start);
-    if (benchmark_name.find(token) != std::string::npos) {
-      return true;
-    }
-    start = end + 1;
-    end = filter.find(',', start);
-  }
-  // Check last token
-  std::string token = filter.substr(start);
-  return benchmark_name.find(token) != std::string::npos;
-}
-
-int main(int argc, char* argv[]) {
-  std::string filter;
-
-  // Parse command-line arguments
-  for (int i = 1; i < argc; ++i) {
-      if (strcmp(argv[i], "-f") == 0 || strcmp(argv[i], "--filter") == 0) {
-          if (i + 1 < argc) {
-              filter = argv[++i];
-          } else {
-              std::cerr << "Error: -f/--filter requires an argument" << std::endl;
-              return EXIT_FAILURE;
-          }
-      }
-  }
-  // Testing correctness of round-trip (serialization + deserialization)
-  simdjson::padded_string json_str = read_file(JSON_FILE);
-
-  // Loading up the data into a structure.
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc;
-  if(parser.iterate(json_str).get(doc)) {
-    std::cerr << "Error loading the document!" << std::endl;
-    return EXIT_FAILURE;
-  }
-  TwitterData my_struct;
-  if(doc.get<TwitterData>().get(my_struct)) {
-    std::cerr << "Error loading TwitterData!" << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  // Benchmarking the serialization
-  // Note: simdjson benchmarks include both "fair" (fresh allocation) and "reuse" (buffer reuse) variants
-  // The "fair" variants allocate fresh memory each iteration, matching other libraries' behavior
-  // The "reuse" variants demonstrate the API's potential when buffer reuse is possible
-
-  if (matches_filter("nlohmann", filter)) {
-    bench_nlohmann(my_struct);
-  }
-#ifdef SIMDJSON_COMPETITION_YYJSON
-  if (matches_filter("yyjson", filter)) {
-    bench_yyjson(my_struct);
-  }
-#endif
-  if (matches_filter("simdjson_static_reflection", filter)) {
-    bench_simdjson_static_reflection(my_struct);
-  }
-  if (matches_filter("simdjson_reuse", filter)) {
-    bench_simdjson_static_reflection_reuse(my_struct);
-  }
-#if SIMDJSON_STATIC_REFLECTION
-  if (matches_filter("simdjson_to", filter)) {
-    bench_simdjson_to(my_struct);
-  }
-  if (matches_filter("simdjson_to_reuse", filter)) {
-    bench_simdjson_to_reuse(my_struct);
-  }
-#endif
-#ifdef SIMDJSON_RUST_VERSION
-  if (matches_filter("rust", filter)) {
-    serde_benchmark::TwitterData * td = serde_benchmark::twitter_from_str(json_str.data(), json_str.size());
-    if (td == nullptr) {
-      printf("# Failed to parse Twitter data for Rust benchmark\n");
-    } else {
-      bench_rust(td);
-      serde_benchmark::free_twitter(td);
-    }
-  }
-#endif
-#if SIMDJSON_BENCH_CPP_REFLECT
-  if (matches_filter("reflect_cpp", filter)) {
-    bench_reflect_cpp(my_struct);
-  }
-#endif
-  return EXIT_SUCCESS;
-}
@@ -1,70 +0,0 @@
-#ifndef NLOHMANN_TWITTER_DATA_H
-#define NLOHMANN_TWITTER_DATA_H
-
-#include "twitter_data.h"
-#include <nlohmann/json.hpp>
-
-// Serialization functions for nlohmann
-void to_json(nlohmann::json &j, const User &u) {
-  j = nlohmann::json{{"id", u.id},
-                     {"name", u.name},
-                     {"screen_name", u.screen_name},
-                     {"location", u.location},
-                     {"description", u.description},
-                     {"verified", u.verified},
-                     {"followers_count", u.followers_count},
-                     {"friends_count", u.friends_count},
-                     {"statuses_count", u.statuses_count}};
-}
-
-void to_json(nlohmann::json &j, const Status &s) {
-  j = nlohmann::json{{"created_at", s.created_at},
-                     {"id", s.id},
-                     {"text", s.text},
-                     {"user", s.user},
-                     {"retweet_count", s.retweet_count},
-                     {"favorite_count", s.favorite_count}};
-}
-
-void to_json(nlohmann::json &j, const TwitterData &t) {
-  j = nlohmann::json{{"statuses", t.statuses}};
-}
-
-// Deserialization functions for nlohmann
-void from_json(const nlohmann::json &j, User &u) {
-  j.at("id").get_to(u.id);
-  j.at("name").get_to(u.name);
-  j.at("screen_name").get_to(u.screen_name);
-  j.at("location").get_to(u.location);
-  j.at("description").get_to(u.description);
-  j.at("verified").get_to(u.verified);
-  j.at("followers_count").get_to(u.followers_count);
-  j.at("friends_count").get_to(u.friends_count);
-  j.at("statuses_count").get_to(u.statuses_count);
-}
-
-void from_json(const nlohmann::json &j, Status &s) {
-  j.at("created_at").get_to(s.created_at);
-  j.at("id").get_to(s.id);
-  j.at("text").get_to(s.text);
-  j.at("user").get_to(s.user);
-  j.at("retweet_count").get_to(s.retweet_count);
-  j.at("favorite_count").get_to(s.favorite_count);
-}
-
-void from_json(const nlohmann::json &j, TwitterData &t) {
-  j.at("statuses").get_to(t.statuses);
-}
-
-// Helper functions for benchmarking
-std::string nlohmann_serialize(const TwitterData &data) {
-  nlohmann::json j = data;
-  return j.dump();
-}
-
-TwitterData nlohmann_deserialize(const std::string &json_str) {
-  nlohmann::json j = nlohmann::json::parse(json_str);
-  return j.get<TwitterData>();
-}
-
-#endif // NLOHMANN_TWITTER_DATA_H
@@ -1,142 +0,0 @@
-#ifndef RAPIDJSON_TWITTER_DATA_H
-#define RAPIDJSON_TWITTER_DATA_H
-
-#include "twitter_data.h"
-#include <rapidjson/document.h>
-#include <rapidjson/writer.h>
-#include <rapidjson/stringbuffer.h>
-#include <rapidjson/error/en.h>
-
-using namespace rapidjson;
-
-// RapidJSON deserialization for simplified Twitter data
-TwitterData rapidjson_deserialize(const std::string& json_str) {
-    Document doc;
-    doc.Parse(json_str.c_str());
-
-    if (doc.HasParseError()) {
-        throw std::runtime_error("RapidJSON parse error");
-    }
-
-    TwitterData data;
-
-    if (!doc.HasMember("statuses") || !doc["statuses"].IsArray()) {
-        return data;
-    }
-
-    const Value& statuses = doc["statuses"];
-    data.statuses.reserve(statuses.Size());
-
-    for (SizeType i = 0; i < statuses.Size(); i++) {
-        const Value& status_json = statuses[i];
-        Status status;
-
-        // Parse status fields
-        if (status_json.HasMember("created_at") && status_json["created_at"].IsString())
-            status.created_at = status_json["created_at"].GetString();
-        if (status_json.HasMember("id") && status_json["id"].IsUint64())
-            status.id = status_json["id"].GetUint64();
-        if (status_json.HasMember("text") && status_json["text"].IsString())
-            status.text = status_json["text"].GetString();
-        if (status_json.HasMember("retweet_count") && status_json["retweet_count"].IsUint64())
-            status.retweet_count = status_json["retweet_count"].GetUint64();
-        if (status_json.HasMember("favorite_count") && status_json["favorite_count"].IsUint64())
-            status.favorite_count = status_json["favorite_count"].GetUint64();
-
-        // Parse user
-        if (status_json.HasMember("user") && status_json["user"].IsObject()) {
-            const Value& user_json = status_json["user"];
-            User user;
-
-            if (user_json.HasMember("id") && user_json["id"].IsUint64())
-                user.id = user_json["id"].GetUint64();
-            if (user_json.HasMember("name") && user_json["name"].IsString())
-                user.name = user_json["name"].GetString();
-            if (user_json.HasMember("screen_name") && user_json["screen_name"].IsString())
-                user.screen_name = user_json["screen_name"].GetString();
-            if (user_json.HasMember("location") && user_json["location"].IsString())
-                user.location = user_json["location"].GetString();
-            if (user_json.HasMember("description") && user_json["description"].IsString())
-                user.description = user_json["description"].GetString();
-            if (user_json.HasMember("verified") && user_json["verified"].IsBool())
-                user.verified = user_json["verified"].GetBool();
-            if (user_json.HasMember("followers_count") && user_json["followers_count"].IsUint64())
-                user.followers_count = user_json["followers_count"].GetUint64();
-            if (user_json.HasMember("friends_count") && user_json["friends_count"].IsUint64())
-                user.friends_count = user_json["friends_count"].GetUint64();
-            if (user_json.HasMember("statuses_count") && user_json["statuses_count"].IsUint64())
-                user.statuses_count = user_json["statuses_count"].GetUint64();
-
-            status.user = user;
-        }
-
-        data.statuses.push_back(status);
-    }
-
-    return data;
-}
-
-// RapidJSON serialization for simplified Twitter data
-std::string rapidjson_serialize(const TwitterData& data) {
-    Document doc;
-    doc.SetObject();
-    Document::AllocatorType& allocator = doc.GetAllocator();
-
-    Value statuses_array(kArrayType);
-
-    for (const auto& status : data.statuses) {
-        Value status_obj(kObjectType);
-
-        Value created_at;
-        created_at.SetString(status.created_at.c_str(), allocator);
-        status_obj.AddMember("created_at", created_at, allocator);
-
-        status_obj.AddMember("id", status.id, allocator);
-
-        Value text;
-        text.SetString(status.text.c_str(), allocator);
-        status_obj.AddMember("text", text, allocator);
-
-        // Add user
-        Value user_obj(kObjectType);
-        user_obj.AddMember("id", status.user.id, allocator);
-
-        Value name;
-        name.SetString(status.user.name.c_str(), allocator);
-        user_obj.AddMember("name", name, allocator);
-
-        Value screen_name;
-        screen_name.SetString(status.user.screen_name.c_str(), allocator);
-        user_obj.AddMember("screen_name", screen_name, allocator);
-
-        Value location;
-        location.SetString(status.user.location.c_str(), allocator);
-        user_obj.AddMember("location", location, allocator);
-
-        Value description;
-        description.SetString(status.user.description.c_str(), allocator);
-        user_obj.AddMember("description", description, allocator);
-
-        user_obj.AddMember("verified", status.user.verified, allocator);
-        user_obj.AddMember("followers_count", status.user.followers_count, allocator);
-        user_obj.AddMember("friends_count", status.user.friends_count, allocator);
-        user_obj.AddMember("statuses_count", status.user.statuses_count, allocator);
-
-        status_obj.AddMember("user", user_obj, allocator);
-
-        status_obj.AddMember("retweet_count", status.retweet_count, allocator);
-        status_obj.AddMember("favorite_count", status.favorite_count, allocator);
-
-        statuses_array.PushBack(status_obj, allocator);
-    }
-
-    doc.AddMember("statuses", statuses_array, allocator);
-
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    doc.Accept(writer);
-
-    return buffer.GetString();
-}
-
-#endif // RAPIDJSON_TWITTER_DATA_H
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Daniel Lemire	207b626f5b	extractor PR with clangcl tweaks	2024-09-21 12:35:29 -04:00
M. Bahoosh	fe6c5401b0	MSVC Fix	2024-09-21 04:35:08 -10:00
M. Bahoosh	d9545b2d6e	value_iterator::on_field_raw noexcept	2024-09-21 01:09:46 -10:00
M. Bahoosh	6f19ccb81a	value_iterator::on_field_raw to optimize object::extract	2024-09-21 00:44:20 -10:00
M. Bahoosh	f7bf592f13	Merge pull request #1 from simdjson/extractor_bench adding benchmark to extractor	2024-09-21 03:39:23 -07:00
Daniel Lemire	677674d54a	update	2024-09-20 20:40:23 -04:00
Daniel Lemire	949bc5142c	adding benchmark to extractor	2024-09-20 20:32:47 -04:00
M. Bahoosh	b4d72ff70a	explicitly ignoring to fix clang	2024-09-14 00:56:26 -10:00
M. Bahoosh	c8bde7cff0	Propagating errors	2024-09-13 04:45:19 -10:00
M. Bahoosh	a4e3e386a0	Fix msvc and clang and gcc error	2024-09-13 02:55:57 -10:00
M. Bahoosh	c343f6979c	Moving things around to fix msvc error	2024-09-13 02:35:03 -07:00
M. Bahoosh	bee5593cb2	Add macro	2024-09-13 01:42:19 -10:00
M. Bahoosh	dfde6d5e44	sub	2024-09-13 01:40:16 -10:00
M. Bahoosh	414c5858ae	noexcept-friendlification of endpoints	2024-09-12 21:55:13 -10:00
M. Bahoosh	142c9a93f8	Remove unnecessary function call	2024-09-12 09:04:28 -10:00
M. Bahoosh	b4e7d717fc	Optimize object::extract's performance	2024-09-12 08:52:22 -10:00
M. Bahoosh	bba20807be	object::extract This is the bare minimum implementation of this idea.	2024-09-12 08:37:58 -10:00