Patch release 0.7.1

Updating according to John's comments.
Definining SIMDJSON_CAN_ALWAYS_RUN_PPC64 and SIMDJSON_CAN_ALWAYS_RUN_ARM64
2026-06-08 17:27:07 +00:00 · 2020-12-14 10:44:01 -05:00 · 2020-12-13 20:01:10 -05:00 · 2020-12-13 19:38:38 -05:00 · 2020-12-13 18:58:28 -05:00 · 2020-12-13 18:50:14 -05:00
341 changed files with 54012 additions and 13730 deletions
@@ -4,7 +4,13 @@ configuration: Release
 image: Visual Studio 2019
 platform: x64

+cache:
+  - C:\dependencies -> dependencies\CMakeLists.txt
+
 environment:
+  # Forward slash is used because this is used in CMake as is
+  simdjson_DEPENDENCY_CACHE_DIR: C:/dependencies
+
  matrix:
    - job_name: VS2019
      CMAKE_ARGS:  -A %Platform%
@@ -17,7 +23,11 @@ environment:
    - job_name: VS2019 (Win32)
      platform: Win32
      CMAKE_ARGS:  -A %Platform% -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_ENABLE_THREADS=ON # This should be the default. Testing anyway.
-      CTEST_ARGS: -E checkperf
+      CTEST_ARGS: -E "checkperf|ondemand_basictests"
+    - job_name: VS2019 (Win32, No Exceptions)
+      platform: Win32
+      CMAKE_ARGS:  -A %Platform% -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_ENABLE_THREADS=ON -DSIMDJSON_EXCEPTIONS=OFF
+      CTEST_ARGS: -E "checkperf|ondemand_basictests"
    - job_name: VS2015
      image: Visual Studio 2015
      CMAKE_ARGS:  -A %Platform% -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_ENABLE_THREADS=OFF
@@ -1,5 +1,8 @@
 version: 2.1

+
+# We constantly run out of memory so please do not use parallelism (-j, -j4). 
+
 # Reusable image / compiler definitions
 executors:
  gcc8:
@@ -8,8 +11,8 @@ executors:
        environment:
          CXX: g++-8
          CC: gcc-8
-          BUILD_FLAGS: -j
-          CTEST_FLAGS: -j4 --output-on-failure
+          BUILD_FLAGS: 
+          CTEST_FLAGS: --output-on-failure

  gcc9:
    docker:
@@ -17,8 +20,8 @@ executors:
        environment:
          CXX: g++-9
          CC: gcc-9
-          BUILD_FLAGS: -j
-          CTEST_FLAGS: -j4 --output-on-failure
+          BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure

  gcc10:
    docker:
@@ -26,8 +29,8 @@ executors:
        environment:
          CXX: g++-10
          CC: gcc-10
-          BUILD_FLAGS: -j
-          CTEST_FLAGS: -j4 --output-on-failure
+          BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure

  clang10:
    docker:
@@ -35,8 +38,8 @@ executors:
        environment:
          CXX: clang++-10
          CC: clang-10
-          BUILD_FLAGS: -j
-          CTEST_FLAGS: -j4 --output-on-failure
+          BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure

  clang9:
    docker:
@@ -44,8 +47,8 @@ executors:
        environment:
          CXX: clang++-9
          CC: clang-9
-          BUILD_FLAGS: -j
-          CTEST_FLAGS: -j4 --output-on-failure
+          BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure 

  clang6:
    docker:
@@ -53,11 +56,24 @@ executors:
        environment:
          CXX: clang++-6.0
          CC: clang-6.0
-          BUILD_FLAGS: -j
-          CTEST_FLAGS: -j4 --output-on-failure
+          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
@@ -68,19 +84,24 @@ commands:
      - checkout
      - run: mkdir -p build

-  cmake_build:
+  cmake_build_cache:
    steps:
      - cmake_prep
-      - run: |
-          cd build &&
-          cmake $CMAKE_FLAGS -DCMAKE_INSTALL_PREFIX:PATH=destination .. &&
-          make $BUILD_FLAGS all
+      - dependency_restore
+      - run: cmake $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 &&
+          cd build &&
+          tools/json2json -h &&
          ctest $CTEST_FLAGS -L acceptance &&
          ctest $CTEST_FLAGS -LE acceptance -E checkperf

@@ -88,13 +109,23 @@ commands:
    steps:
      - cmake_build
      - run: |
-          cd build &&  tools/json2json -h &&
-          ctest $CTEST_FLAGS -L acceptance -LE per_implementation &&
-          SIMDJSON_FORCE_IMPLEMENTATION=haswell ctest $CTEST_FLAGS -L per_implementation &&
-          SIMDJSON_FORCE_IMPLEMENTATION=westmere ctest $CTEST_FLAGS -L per_implementation &&SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation &&
+          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 -E checkperf &&
+          SIMDJSON_FORCE_IMPLEMENTATION=westmere ctest $CTEST_FLAGS -L per_implementation -E checkperf &&
+          SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation -E checkperf &&
          ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.


+  cmake_perftest:
+    steps:
+      - cmake_build_cache
+      - run: |
+          cmake --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:
@@ -113,11 +144,16 @@ jobs:
    executor: gcc10
    environment: { CMAKE_FLAGS: -DSIMDJSON_JUST_LIBRARY=ON }
    steps: [ cmake_build, cmake_install_test, cmake_installed_test_cxx20 ]
+  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 -DSIMDJSON_BUILD_STATIC=ON }
+    steps: [ cmake_perftest ]
  gcc10:
-    description: Build and run tests on GCC 10 and AVX 2 with a cmake static build, this test performance regression
+    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 -DSIMDJSON_BUILD_STATIC=ON }
-    steps: [ cmake_test_all, cmake_install_test, cmake_installed_test_cxx20 ]
+    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
@@ -138,14 +174,23 @@ jobs:
  sanitize-gcc10:
    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
    executor: gcc10
-    environment: { CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON, BUILD_FLAGS: "", CTEST_FLAGS: -j4 --output-on-failure -E checkperf }
+    environment: { CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON, BUILD_FLAGS: "", CTEST_FLAGS: --output-on-failure -E checkperf }
    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: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: -j4 --output-on-failure -E checkperf }
+    environment: { CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -E checkperf }
+    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: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE_THREADS=ON, BUILD_FLAGS: "", CTEST_FLAGS: --output-on-failure -E checkperf }
+    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: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE_THREADS=ON, CTEST_FLAGS: --output-on-failure -E checkperf }
    steps: [ cmake_test ]
-
  # dynamic
  dynamic-gcc10:
    description: Build and run tests on GCC 10 and AVX 2 with a cmake dynamic build
@@ -188,15 +233,25 @@ jobs:

  # make (test and checkperf)
  arch-haswell-gcc10:
-    description: Build, run tests and check performance on GCC 7 with -march=haswell
+    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 7 with -march=nehalem
+    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: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON, BUILD_FLAGS: "", CTEST_FLAGS: --output-on-failure -E checkperf }
+    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: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -E checkperf }
+    steps: [ cmake_test ]

 workflows:
  version: 2.1
@@ -214,6 +269,8 @@ workflows:
      # full single-implementation tests
      - sanitize-gcc10
      - sanitize-clang10
+      - threadsanitize-gcc10
+      - threadsanitize-clang10
      - dynamic-gcc10
      - dynamic-clang10
      - unthreaded-gcc10
@@ -227,6 +284,11 @@ workflows:
      - arch-haswell-gcc10
      - arch-nehalem-gcc10

+
+      # sanitized single-implementation tests
+      - sanitize-haswell-gcc10
+      - sanitize-haswell-clang10
+
      # testing "just the library"
      - justlib-gcc10

@@ -6,6 +6,11 @@ task:

  env:
    ASSUME_ALWAYS_YES: YES
+    simdjson_DEPENDENCY_CACHE_DIR: $HOME/.dep_cache
+  dep_cache:
+    folder: $HOME/.dep_cache
+    reupload_on_changes: false
+    fingerprint_script: cat dependencies/CMakeLists.txt
  setup_script:
    - pkg update -f
    - pkg install bash
@@ -1,7 +1,7 @@
 *
 !.git
 !Makefile
-!amalgamate.sh
+!amalgamate.py
 !benchmark
 !dependencies
 !include
@@ -12,4 +12,4 @@
 !src
 !style
 !tests
-!tools
+!tools
@@ -11,8 +11,8 @@ steps:
    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf 
  commands:
-    - apt-get update -qq
-    - apt-get install -y g++ cmake gcc
+    - scripts/addcmakeppa.sh "$(env -i sh -c '. /etc/os-release; echo $VERSION_CODENAME')"
+    - apt-get install -y g++ cmake gcc git
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -32,8 +32,8 @@ steps:
    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf 
  commands:
-    - apt-get update -qq
-    - apt-get install -y clang++-6.0 cmake
+    - scripts/addcmakeppa.sh "$(env -i sh -c '. /etc/os-release; echo $VERSION_CODENAME')"
+    - apt-get install -y clang++-6.0 cmake git
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -50,11 +50,12 @@ steps:
    CC: gcc
    CXX: g++
    BUILD_FLAGS: -- -j
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_IMPLEMENTATION=haswell;westmere;fallback
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
    - apt-get update -qq
-    - apt-get install -y cmake
+    - apt-get -t buster-backports install -y cmake
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -76,7 +77,7 @@ steps:
    CC: clang-6.0
    CXX: clang++-6.0
    BUILD_FLAGS: -- -j
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_IMPLEMENTATION=haswell;westmere;fallback
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
  commands:
    - mkdir build
@@ -102,8 +103,9 @@ steps:
    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
    - apt-get update -qq
-    - apt-get install -y cmake
+    - apt-get -t buster-backports install -y cmake
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -140,11 +142,12 @@ steps:
    CC: gcc
    CXX: g++
    BUILD_FLAGS: -- -j
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_IMPLEMENTATION=haswell;westmere;fallback
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
    - apt-get update -qq
-    - apt-get install -y cmake
+    - apt-get -t buster-backports install -y cmake
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -165,7 +168,7 @@ steps:
  environment:
    CC: clang-9
    CXX: clang++-9
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON
+    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON -DSIMDJSON_IMPLEMENTATION=haswell;westmere;fallback
    BUILD_FLAGS: -- -j
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
  commands:
@@ -180,6 +183,27 @@ steps:
    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
 ---
 kind: pipeline
+name: cpp20-clang11-libcpp
+platform: { os: linux, arch: amd64 }
+steps:
+- name: Build and Test
+  image: pauldreik/llvm-11
+  user: root
+  environment:
+    CC: clang-11
+    CXX: clang++-11
+    CMAKE_FLAGS: -GNinja
+    BUILD_FLAGS:
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
+    CXXFLAGS: -std=c++20 -stdlib=libc++
+  commands:
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
+---
+kind: pipeline
 name: arm64-gcc8
 platform: { os: linux, arch: arm64 }
 steps:
@@ -189,11 +213,12 @@ steps:
    CC: gcc
    CXX: g++
    BUILD_FLAGS: -- -j
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_IMPLEMENTATION=arm64;fallback
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
    - apt-get update -qq
-    - apt-get install -y cmake
+    - apt-get -t buster-backports install -y cmake
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -208,7 +233,7 @@ name: arm64-clang6
 platform: { os: linux, arch: arm64 }
 steps:
 - name: Build and Test
-  image: ubuntu:18.04
+  image: debian:buster-backports
  environment:
    CC: clang-6.0
    CXX: clang++-6.0
@@ -216,8 +241,9 @@ steps:
    BUILD_FLAGS: -- -j
    CTEST_FLAGS: -j4 --output-on-failure  -E checkperf
  commands:
-    - apt-get update -qq
-    - apt-get install -y clang cmake git
+    - apt-get -qq update
+    - apt-get -t buster-backports install -y cmake
+    - apt-get install -y clang-6.0 git
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -237,8 +263,9 @@ steps:
    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
    - apt-get update -qq
-    - apt-get install -y cmake
+    - apt-get -t buster-backports install -y cmake
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -250,7 +277,7 @@ name: arm64-dynamic-clang6
 platform: { os: linux, arch: arm64 }
 steps:
 - name: Build and Test
-  image: ubuntu:18.04
+  image: debian:buster-backports
  environment:
    CC: clang-6.0
    CXX: clang++-6.0
@@ -258,8 +285,9 @@ steps:
    BUILD_FLAGS: -- -j
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
  commands:
-    - apt-get update -qq
-    - apt-get install -y clang cmake git
+    - apt-get -qq update
+    - apt-get -t buster-backports install -y cmake
+    - apt-get install -y clang-6.0 git
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -274,13 +302,15 @@ steps:
  image: gcc:8
  environment:
    BUILD_FLAGS: -- -j
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_IMPLEMENTATION=arm64;fallback
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
    CC: gcc
    CXX: g++
  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
    - apt-get update -qq
-    - apt-get install -y cmake libstdc++6
+    - apt-get -t buster-backports install -y cmake
+    - apt-get install -y libstdc++6
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -295,16 +325,17 @@ name: arm64-sanitize-clang6
 platform: { os: linux, arch: arm64 }
 steps:
 - name: Build and Test
-  image: ubuntu:18.04
+  image: debian:buster-backports
  environment:
    CC: clang-6.0
    CXX: clang++-6.0
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON
+    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON -DSIMDJSON_IMPLEMENTATION=arm64;fallback
    BUILD_FLAGS: -- -j
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
  commands:
-    - apt-get update -qq
-    - apt-get install -y clang cmake git
+    - apt-get -qq update
+    - apt-get -t buster-backports install -y cmake
+    - apt-get install -y clang-6.0 git
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -326,11 +357,9 @@ steps:
    CXX: clang++-9
    BUILD_FLAGS: -- -j 4
    CMAKE_FLAGS: -GNinja -DSIMDJSON_BUILD_STATIC=ON
-    CTEST_FLAGS: -j4 --output-on-failure
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
    CXXFLAGS: -stdlib=libc++
  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -352,8 +381,27 @@ steps:
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
    CXXFLAGS: -stdlib=libc++
  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
+---
+kind: pipeline
+name: libcpp-clang7
+platform: { os: linux, arch: amd64 }
+steps:
+- name: Build and Test
+  image: conanio/clang7
+  user: root
+  environment:
+    CC: clang-7
+    CXX: clang++-7
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
+    CXXFLAGS: -stdlib=libc++
+  commands:
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -373,8 +421,9 @@ steps:
    CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF
    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
    - apt-get update -qq
-    - apt-get install -y cmake
+    - apt-get -t buster-backports install -y cmake
    - mkdir build
    - cd build
    - cmake $CMAKE_FLAGS ..
@@ -382,6 +431,26 @@ steps:
    - ctest $CTEST_FLAGS
 ---
 kind: pipeline
+name: arm64-fuzz
+platform: { os: linux, arch: arm64 }
+steps:
+- name: Build and run fuzzers shortly
+  image: ubuntu:20.04
+  environment:
+    CC: clang
+    CXX: clang++
+    DEBIAN_FRONTEND: noninteractive
+    ASAN_OPTIONS: detect_leaks=0
+  commands:
+    - apt-get -qq update
+    - apt-get install -q -y clang cmake git wget zip ninja-build
+    - wget --quiet https://dl.bintray.com/pauldreik/simdjson-fuzz-corpus/corpus/corpus.tar
+    - tar xf corpus.tar && rm corpus.tar
+    - fuzz/build_like_ossfuzz.sh
+    - mkdir -p common_out
+    - for fuzzer in build/fuzz/fuzz_* ; do echo $fuzzer;$fuzzer common_out out/* -max_total_time=40; done
+---
+kind: pipeline
 name: stylecheck
 platform: { os: linux, arch: amd64 }
 steps:
@@ -12,12 +12,13 @@ Before submitting an issue, please ensure that you have read the documentation:
 * 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).


 **Describe the bug**
 A clear and concise description of what the bug is.

-Note that a compiler warning is not a bug. 
+Note that a compiler warning is not a bug.

 **To Reproduce**
 Steps to reproduce the behaviour: provide a code sample if possible.
@@ -31,10 +32,10 @@ Note that a stack trace from your own program is not enough.
 - Compiler [e.g. Apple clang version 11.0.3 (clang-1103.0.32.59) x86_64-apple-darwin19.4.0]
 - Version [e.g. 22]

-We support up-to-date 64-bit ARM and x64 FreeBSD, macOS, Windows and Linux systems. Please ensure that your configuration is supported before labelling the issue as a bug. In particular, we do not support legacy 32-bit systems. 
+We support up-to-date 64-bit ARM and x64 FreeBSD, macOS, Windows and Linux systems. Please ensure that your configuration is supported before labelling the issue as a bug. In particular, we do not support legacy 32-bit systems.

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

-If you plan to contribute to simdjson, please read our 
+If you plan to contribute to simdjson, please read our
 * CONTRIBUTING guide: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md and our
 * HACKING guide: https://github.com/simdjson/simdjson/blob/master/HACKING.md
@@ -12,6 +12,7 @@ Before submitting an issue, please ensure that you have read the documentation:
 * 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).

 We do not make changes to simdjson without clearly identifiable benefits, which typically means either performance improvements, bug fixes or new features. Avoid bike-shedding: we all have opinions about how to write code, but we want to focus on what makes simdjson objectively better.

@@ -31,6 +32,6 @@ A clear and concise description of any alternative solutions or features you've
 Add any other context or screenshots about the feature request here.

 ** Are you willing to contribute code or documentation toward this new feature? **
-If you plan to contribute to simdjson, please read our 
+If you plan to contribute to simdjson, please read our
 * CONTRIBUTING guide: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md and our
 * HACKING guide: https://github.com/simdjson/simdjson/blob/master/HACKING.md
@@ -12,6 +12,7 @@ Before submitting an issue, please ensure that you have read the documentation:
 * 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).

 We do not make changes to simdjson without clearly identifiable benefits, which typically means either performance improvements, bug fixes or new features. Avoid bike-shedding: we all have opinions about how to write code, but we want to focus on what makes simdjson objectively better.

@@ -26,6 +27,6 @@ Is your issue:
 4. A documentation issue? Can you suggest an improvement?


-If you plan to contribute to simdjson, please read our 
+If you plan to contribute to simdjson, please read our
 * CONTRIBUTING guide: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md and our
 * HACKING guide: https://github.com/simdjson/simdjson/blob/master/HACKING.md
@@ -0,0 +1,8 @@
+
+
+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
+
+CONTRIBUTING guide: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md and our
+HACKING guide: https://github.com/simdjson/simdjson/blob/master/HACKING.md
@@ -0,0 +1,37 @@
+name: Alpine Linux
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: start docker
+        run: |
+          docker run -w /src -dit --name alpine -v $PWD:/src alpine:latest
+          echo 'docker exec alpine "$@";' > ./alpine.sh
+          chmod +x ./alpine.sh
+      - name: install packages
+        run: |
+          ./alpine.sh apk update
+          ./alpine.sh apk add build-base cmake g++ linux-headers git bash
+      - name: cmake
+        run: |
+          ./alpine.sh cmake -B build_for_alpine
+      - name: build
+        run: |
+          ./alpine.sh cmake --build build_for_alpine
+      - name: test
+        run: |
+          ./alpine.sh bash -c "cd build_for_alpine && ctest  -E checkperf"
@@ -0,0 +1,37 @@
+name: Detect trailing whitespace
+
+on:
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  whitespace:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - name: Remove whitespace and check the diff
+        run: |
+          set -eu
+          scripts/remove_trailing_whitespace.sh
+          git diff >whitespace.patch
+          cat whitespace.patch
+          if [ $(wc -c <whitespace.patch) -ne 0 ] ; then
+             echo " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! "
+             echo "You have trailing whitespace, please download the artifact"
+             echo "and apply with git apply <whitespace.patch or"
+             echo "run scripts/remove_trailing_whitespace.sh locally."
+             echo " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! "
+             exit 1
+          else
+             echo "no trailing whitespace found, good!"
+          fi
+      - name: Archive whitespace patch
+        uses: actions/upload-artifact@v2
+        if: always()
+        with:
+          name: whitespace-patch
+          path: |
+            whitespace.patch
+          if-no-files-found: ignore
+
@@ -1,12 +1,12 @@
-name: Run fuzzers on stored corpus and test it with valgrind
+name: Fuzz and run valgrind

-# In the case of a pull request happening at the same time as a cron
-# job, there is a risk two jobs run at the same time. Therefore,
-# the corpus is only uploaded for the master branch. Pull requests will
-# fuzz for a short while, but the results are not uploaded.
 on:
  push:
+    branches:
+      - master
  pull_request:
+    branches:
+      - master
  schedule:
    - cron: 23 */8 * * *

@@ -14,8 +14,17 @@ jobs:
  build:    
    runs-on: ubuntu-latest
    env:
-      allfuzzers: parser dump dump_raw_tape print_json
-      artifactsprefix: -artifact_prefix=fuzzfailure/
+      # fuzzers that change behaviour with SIMDJSON_FORCE_IMPLEMENTATION
+      defaultimplfuzzers: atpointer dump dump_raw_tape element minify parser print_json
+      # fuzzers that loop over the implementations themselves, or don't need to switch.
+      implfuzzers: implementations minifyimpl ndjson ondemand padded utf8
+      implementations: haswell westmere fallback
+      UBSAN_OPTIONS: halt_on_error=1
+      MAXLEN: -max_len=4000
+      CLANGVERSION: 11
+      # which optimization level to use for the sanitizer build (see build_fuzzer.variants.sh)
+      OPTLEVEL: -O3
+
    steps:
    - name: Install packages necessary for building
      run: |
@@ -23,105 +32,130 @@ jobs:
        sudo apt-get install --quiet ninja-build valgrind zip unzip
        wget https://apt.llvm.org/llvm.sh
        chmod +x llvm.sh
-        sudo ./llvm.sh 9
+        sudo ./llvm.sh $CLANGVERSION

    - uses: actions/checkout@v1
+
+    - uses: actions/cache@v2
+      with:
+        path: dependencies/.cache
+        key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+
    - name: Create and prepare the initial seed corpus
      run: |
        fuzz/build_corpus.sh
        mv corpus.zip seed_corpus.zip
+        mkdir seedcorpus
+        unzip -q -d seedcorpus seed_corpus.zip
+
    - name: Download the corpus from the last run
      run: |
        wget --quiet https://dl.bintray.com/pauldreik/simdjson-fuzz-corpus/corpus/corpus.tar
        tar xf corpus.tar
        rm corpus.tar
+
    - name: List clang versions
      run: |
        ls /usr/bin/clang*
        which clang++
        clang++ --version
+
    - name: Build all the variants
-      run: fuzz/build_fuzzer_variants.sh
-    - name: Verify that the oss-fuzz seed corpus passes without problems
+      run: CLANGSUFFIX=-$CLANGVERSION fuzz/build_fuzzer_variants.sh
+
+    - name: Explore fast (release build, default implementation)
      run: |
-        mkdir seedcorpus
-        unzip -q -d seedcorpus seed_corpus.zip
-        for buildvariant in noavx withavx; do
-          for fuzzer in $allfuzzers; do
-            build-ossfuzz-$buildvariant/fuzz/fuzz_$fuzzer seedcorpus -max_total_time=1
-          done
-        done
-    - name: Run the fastest fuzzer to explore fast
-      run: |
-        for fuzzer in $allfuzzers; do
+        set -eux
+        for fuzzer in $defaultimplfuzzers $implfuzzers; do
          mkdir -p out/$fuzzer # in case this is a new fuzzer, or corpus.tar is broken
-          build-ossfuzz-fast9/fuzz/fuzz_$fuzzer         out/$fuzzer -max_total_time=30 $artifactsprefix || touch failed
-          # make sure the failing output is visible in the log
-          if [ -e failed ] ; then
-            ls fuzzfailure/* |xargs -n1 base64
-            exit 1
-          fi
+          # get input from everyone else (corpus cross pollination)
+          others=$(find out -type d -not -name $fuzzer -not -name out -not -name cmin)
+          build-fast/fuzz/fuzz_$fuzzer out/$fuzzer $others seedcorpus -max_total_time=30 $MAXLEN
        done
-    - name: Run the other fuzzer variants for $fuzzer, with sanitizers etc
+
+    - name: Fuzz default impl. fuzzers with sanitizer+asserts (good at detecting errors)
      run: |
-        set -x
-        for fuzzer in $allfuzzers; do
-          build-ossfuzz-withavx/fuzz/fuzz_$fuzzer       out/$fuzzer -max_total_time=20 $artifactsprefix || touch failed
-          build-ossfuzz-noavx/fuzz/fuzz_$fuzzer         out/$fuzzer -max_total_time=10 $artifactsprefix || touch failed
-          build-ossfuzz-noavx9/fuzz/fuzz_$fuzzer        out/$fuzzer -max_total_time=10 $artifactsprefix || touch failed
-          if [ -e failed ] ; then
-            # make sure the failing output is visible in the log
-            ls fuzzfailure/* |xargs -n1 base64
-            exit 1
-          fi
-          echo disable msan runs, it fails inside the fuzzing engine and not the fuzzed code!
-          echo build-ossfuzz-msan-noavx9/fuzz/fuzz_$fuzzer   out/$fuzzer -max_total_time=10 -reload=0 $artifactsprefix
-          echo build-ossfuzz-msan-withavx9/fuzz/fuzz_$fuzzer out/$fuzzer -max_total_time=10 -reload=0 $artifactsprefix
+        set -eux
+        for fuzzer in $defaultimplfuzzers; do
+          # get input from everyone else (corpus cross pollination)
+          others=$(find out -type d -not -name $fuzzer -not -name out -not -name cmin)
+          for implementation in $implementations; do
+            export SIMDJSON_FORCE_IMPLEMENTATION=$implementation
+            build-sanitizers$OPTLEVEL/fuzz/fuzz_$fuzzer out/$fuzzer $others seedcorpus -max_total_time=20 $MAXLEN
+          done
          echo now have $(ls out/$fuzzer |wc -l) files in corpus        
        done
-    - name: Minimize the corpus with the fast fuzzer
+
+    - name: Fuzz differential impl. fuzzers with sanitizer+asserts (good at detecting errors)
      run: |
-        for fuzzer in $allfuzzers; do      
+        set -eux
+        for fuzzer in $implfuzzers; do
+          # get input from everyone else (corpus cross pollination)
+          others=$(find out -type d -not -name $fuzzer -not -name out -not -name cmin)
+          build-sanitizers$OPTLEVEL/fuzz/fuzz_$fuzzer out/$fuzzer $others seedcorpus -max_total_time=20 $MAXLEN
+          echo now have $(ls out/$fuzzer |wc -l) files in corpus
+        done
+
+    - name: Minimize the corpus with the fast fuzzer on the default implementation
+      run: |
+        set -eux
+        for fuzzer in $defaultimplfuzzers $implfuzzers; do
          mkdir -p out/cmin/$fuzzer
-          build-ossfuzz-fast9/fuzz/fuzz_$fuzzer -merge=1  out/cmin/$fuzzer out/$fuzzer
+          # get input from everyone else (corpus cross pollination)
+          others=$(find out -type d -not -name $fuzzer -not -name out -not -name cmin)
+          build-fast/fuzz/fuzz_$fuzzer -merge=1 $MAXLEN out/cmin/$fuzzer out/$fuzzer $others seedcorpus
          rm -rf out/$fuzzer
          mv out/cmin/$fuzzer out/$fuzzer
        done
+
    - name: Package the corpus into an artifact
      run: |
-        for fuzzer in $allfuzzers; do      
+        for fuzzer in $defaultimplfuzzers $implfuzzers; do      
          tar rf corpus.tar out/$fuzzer
        done
+
    - name: Save the corpus as a github artifact
-      uses: actions/upload-artifact@v1
+      uses: actions/upload-artifact@v2
      with:
        name: corpus
        path: corpus.tar
-    - name: Run the corpus through valgrind (normal build)
+
+    # This takes a subset of the minimized corpus and run it through valgrind. It is slow,
+    # therefore take a "random" subset. The random selection is accomplished by sorting on filenames,
+    # which are hashes of the content.
+    - name: Run some of the minimized corpus through valgrind (replay build, default implementation)
      run: |
-        for fuzzer in $allfuzzers; do      
-          find out/$fuzzer -type f |sort|xargs valgrind build-plain-noavx/fuzz/fuzz_$fuzzer  2>&1|tee valgrind-$fuzzer-noavx.txt
-        done
-    - name: Run the corpus through valgrind (noavx build)
-      run: |
-        for fuzzer in $allfuzzers; do      
-          find out/$fuzzer -type f |sort|xargs valgrind build-plain-normal/fuzz/fuzz_$fuzzer 2>&1|tee valgrind-$fuzzer-normal.txt      
-        done  
+        for fuzzer in $defaultimplfuzzers $implfuzzers; do
+          find out/$fuzzer -type f |sort|head -n200|xargs -n40 valgrind build-replay/fuzz/fuzz_$fuzzer 2>&1|tee valgrind-$fuzzer.txt
+        done 
+
    - name: Compress the valgrind output
      run: tar cf valgrind.tar valgrind-*.txt
+
    - name: Save valgrind output as a github artifact
-      uses: actions/upload-artifact@v1
+      uses: actions/upload-artifact@v2
+      if: always()
      with:
        name: valgrindresults
        path: valgrind.tar
+        if-no-files-found: ignore
+
    - name: Upload the corpus and results to bintray if we are on master
+      if: ${{ github.event_name == 'schedule' }} 
      run: |
-        if [ $(git rev-parse --verify HEAD) = $(git rev-parse --verify origin/master) ] ; then
-          echo uploading each artifact twice, otherwise it will not be published
-          curl -T corpus.tar -upauldreik:${{ secrets.bintrayApiKey }} https://api.bintray.com/content/pauldreik/simdjson-fuzz-corpus/corpus/0/corpus/corpus.tar";publish=1;override=1"
-          curl -T corpus.tar -upauldreik:${{ secrets.bintrayApiKey }} https://api.bintray.com/content/pauldreik/simdjson-fuzz-corpus/corpus/0/corpus/corpus.tar";publish=1;override=1"
-          curl -T valgrind.tar -upauldreik:${{ secrets.bintrayApiKey }} https://api.bintray.com/content/pauldreik/simdjson-fuzz-corpus/corpus/0/corpus/valgrind.tar";publish=1;override=1"
-          curl -T valgrind.tar -upauldreik:${{ secrets.bintrayApiKey }} https://api.bintray.com/content/pauldreik/simdjson-fuzz-corpus/corpus/0/corpus/valgrind.tar";publish=1;override=1"
-        else
-          echo "not on master, won't upload to bintray"
-        fi
+        echo uploading each artifact twice, otherwise it will not be published
+        curl -T corpus.tar -upauldreik:${{ secrets.bintrayApiKey }} https://api.bintray.com/content/pauldreik/simdjson-fuzz-corpus/corpus/0/corpus/corpus.tar";publish=1;override=1"
+        curl -T corpus.tar -upauldreik:${{ secrets.bintrayApiKey }} https://api.bintray.com/content/pauldreik/simdjson-fuzz-corpus/corpus/0/corpus/corpus.tar";publish=1;override=1"
+        curl -T valgrind.tar -upauldreik:${{ secrets.bintrayApiKey }} https://api.bintray.com/content/pauldreik/simdjson-fuzz-corpus/corpus/0/corpus/valgrind.tar";publish=1;override=1"
+        curl -T valgrind.tar -upauldreik:${{ secrets.bintrayApiKey }} https://api.bintray.com/content/pauldreik/simdjson-fuzz-corpus/corpus/0/corpus/valgrind.tar";publish=1;override=1"
+
+    - name: Archive any crashes as an artifact
+      uses: actions/upload-artifact@v2
+      if: always()
+      with:
+        name: crashes
+        path: |
+          crash-*
+          leak-*
+          timeout-*
+        if-no-files-found: ignore
@@ -1,6 +1,12 @@
 name: MinGW32-CI

-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master

 # Important: scoop will either install 32-bit GCC or 64-bit GCC, not both.

@@ -26,6 +32,12 @@ jobs:
          path: |
            C:\ProgramData\scoop
          key: scoop32 # static key: should be good forever
+
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+
      - name: Setup Windows # This should almost never run if the cache works.
        if: steps.cache.outputs.cache-hit != 'true'
        shell: powershell
@@ -49,5 +61,5 @@ jobs:
          mkdir build32
          cd build32
          cmake -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_COMPETITION=OFF -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_ENABLE_THREADS=OFF ..
-          cmake --build . --target parse_many_test jsoncheck basictests numberparsingcheck stringparsingcheck errortests integer_tests pointercheck --verbose
+          cmake --build . --target parse_many_test jsoncheck basictests ondemand_basictests numberparsingcheck stringparsingcheck errortests integer_tests pointercheck --verbose
          ctest -R "(parse_many_test|jsoncheck|basictests|stringparsingcheck|numberparsingcheck|errortests|integer_tests|pointercheck)"  --output-on-failure
@@ -1,6 +1,12 @@
 name: MinGW64-CI

-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master

 # Important: scoop will either install 32-bit GCC or 64-bit GCC, not both.

@@ -26,6 +32,12 @@ jobs:
          path: |
            C:\ProgramData\scoop
          key: scoop64 # static key: should be good forever
+
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+
      - name: Setup Windows # This should almost never run if the cache works.
        if: steps.cache.outputs.cache-hit != 'true'
        shell: powershell
@@ -49,11 +61,11 @@ jobs:
          mkdir build64
          cd build64
          cmake -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_COMPETITION=OFF -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_ENABLE_THREADS=OFF ..
-          cmake --build . --target parse_many_test jsoncheck basictests numberparsingcheck stringparsingcheck errortests integer_tests pointercheck --verbose
+          cmake --build . --target parse_many_test jsoncheck basictests ondemand_basictests numberparsingcheck stringparsingcheck errortests integer_tests pointercheck --verbose
          ctest -R "(parse_many_test|jsoncheck|basictests|stringparsingcheck|numberparsingcheck|errortests|integer_tests|pointercheck)"  --output-on-failure
          cd ..
          mkdir build64debug
          cd build64debug
          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_COMPETITION=OFF -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_ENABLE_THREADS=OFF ..
-          cmake --build . --target parse_many_test jsoncheck basictests numberparsingcheck stringparsingcheck errortests integer_tests pointercheck --verbose
+          cmake --build . --target parse_many_test jsoncheck basictests ondemand_basictests numberparsingcheck stringparsingcheck errortests integer_tests pointercheck --verbose
          ctest -R "(parse_many_test|jsoncheck|basictests|stringparsingcheck|numberparsingcheck|errortests|integer_tests|pointercheck)"  --output-on-failure
@@ -1,6 +1,12 @@
 name: MSYS2-CI

-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master

 jobs:
  windows-mingw:
@@ -30,6 +36,10 @@ jobs:

    steps:
      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
      - uses: msys2/setup-msys2@v2
        with:
          update: true
@@ -0,0 +1,26 @@
+name: Performance check on Ubuntu 18.04 CI (GCC 7)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_BUILD_STATIC=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build . --target checkperf  &&
+          ctest --output-on-failure -R checkperf  ubuntu18-checkperf.yml
@@ -0,0 +1,27 @@
+name: Ubuntu 18.04 CI (GCC 7) with Thread Sanitizer
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_SANITIZE_THREADS=ON ..  &&
+          cmake --build . --target 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 +1,28 @@
 name: Ubuntu 18.04 CI (GCC 7)

-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master

 jobs:
  ubuntu-build:
    runs-on: ubuntu-18.04
    steps:
      - uses: actions/checkout@v2
-      - name: Setup cmake
-        uses: jwlawson/actions-setup-cmake@v1.0
+      - uses: actions/cache@v2
        with:
-          cmake-version: '3.9.x'
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
      - name: Use cmake
        run: |
          mkdir build &&
          cd build &&
          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_BUILD_STATIC=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure  &&
+          ctest -j --output-on-failure -E checkperf   &&
          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
@@ -0,0 +1,26 @@
+name: Performance check on Ubuntu 20.04 CI (GCC 9)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_BUILD_STATIC=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build . --target checkperf  &&
+          ctest --output-on-failure -R checkperf 
@@ -0,0 +1,27 @@
+name: Ubuntu 20.04 CI (GCC 9) with Thread Sanitizer
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_SANITIZE_THREADS=ON ..  &&
+          cmake --build . --target 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 +1,28 @@
 name: Ubuntu 20.04 CI (GCC 9)

-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master

 jobs:
  ubuntu-build:
    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v2
-      - name: Setup cmake
-        uses: jwlawson/actions-setup-cmake@v1.0
+      - uses: actions/cache@v2
        with:
-          cmake-version: '3.9.x'
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
      - name: Use cmake
        run: |
          mkdir build &&
          cd build &&
          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_BUILD_STATIC=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure  &&
+          ctest -j --output-on-failure -E checkperf   &&
          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
@@ -1,6 +1,12 @@
 name: VS16-CI

-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master

 jobs:
  ci:
@@ -8,6 +14,10 @@ jobs:
    runs-on: windows-latest
    steps:
    - uses: actions/checkout@v2
+    - uses: actions/cache@v2
+      with:
+        path: dependencies/.cache
+        key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
    - name: 'Run CMake with VS16'
      uses: lukka/run-cmake@v2
      with:
@@ -1,6 +1,12 @@
 name: VS16-CLANG-CI

-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master

 jobs:
  ci:
@@ -8,6 +14,10 @@ jobs:
    runs-on: windows-latest
    steps:
    - uses: actions/checkout@v2
+    - uses: actions/cache@v2
+      with:
+        path: dependencies/.cache
+        key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
    - name: 'Run CMake with VS16'
      uses: lukka/run-cmake@v2
      with:
@@ -22,4 +32,4 @@ jobs:
        
    - name: 'Run CTest'
      run: ctest -C Release -E checkperf  --output-on-failure 
-      working-directory: "${{ github.workspace }}/../../_temp/windows"
+      working-directory: "${{ github.workspace }}/../../_temp/windows"
@@ -1,6 +1,12 @@
 name: VS16-Ninja-CI

-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master

 jobs:
  ci:
@@ -8,6 +14,10 @@ jobs:
    runs-on: windows-latest
    steps:
    - uses: actions/checkout@v2
+    - uses: actions/cache@v2
+      with:
+        path: dependencies/.cache
+        key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
    - name: 'Run CMake with VS16'
      uses: lukka/run-cmake@v2
      with:
@@ -96,3 +96,4 @@ objs

 # Generated docs
 /doc/api
+*.orig
@@ -1,36 +0,0 @@
-[submodule "scalarvssimd/rapidjson"]
-	path = dependencies/rapidjson
-	url = https://github.com/Tencent/rapidjson.git
-[submodule "dependencies/sajson"]
-	path = dependencies/sajson
-	url = https://github.com/chadaustin/sajson.git
-[submodule "dependencies/json11"]
-	path = dependencies/json11
-	url = https://github.com/dropbox/json11.git
-[submodule "dependencies/fastjson"]
-	path = dependencies/fastjson
-	url = https://github.com/mikeando/fastjson.git
-[submodule "dependencies/gason"]
-	path = dependencies/gason
-	url = https://github.com/vivkin/gason.git
-[submodule "dependencies/ujson4c"]
-	path = dependencies/ujson4c
-	url = https://github.com/esnme/ujson4c.git
-[submodule "dependencies/jsmn"]
-	path = dependencies/jsmn
-	url = https://github.com/zserge/jsmn.git
-[submodule "dependencies/cJSON"]
-	path = dependencies/cJSON
-	url = https://github.com/DaveGamble/cJSON.git
-[submodule "dependencies/jsoncpp"]
-	path = dependencies/jsoncpp
-	url = https://github.com/open-source-parsers/jsoncpp.git
-[submodule "dependencies/json"]
-	path = dependencies/json
-	url = https://github.com/nlohmann/json.git
-[submodule "dependencies/benchmark"]
-	path = dependencies/benchmark
-	url = https://github.com/google/benchmark.git
-[submodule "dependencies/cxxopts"]
-	path = dependencies/cxxopts
-	url = https://github.com/jarro2783/cxxopts
@@ -1,30 +1,188 @@
 language: cpp
-sudo: false
-addons:
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-    packages:
-      - gcc-7
-      - g++-7
-      - clang-format
-      - python
-branches:
-  only:
-    - master

-script: 
-   - export CXX=g++-7
-   - export CC=gcc-7
-   - make
-   - make test 
-   - make everything
-   - make amalgamate
-   - make clean
-   - make SANITIZEGOLD=1 test
-   - make clean
-   - ARCHFLAGS="-march=nehalem" make 
-   - ARCHFLAGS="-march=nehalem" make test
-   - ARCHFLAGS="-march=nehalem" make everything
-   - ./style/run-clang-format.py -r include/ benchmark/ src/ tests/
+dist: bionic

+arch:
+  - ppc64le
+
+cache:
+  directories:
+    - $HOME/.dep_cache
+
+env:
+  global:
+    - simdjson_DEPENDENCY_CACHE_DIR=$HOME/.dep_cache
+
+matrix:
+  include:
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-8
+      env:
+        - COMPILER="CC=gcc-8 && CXX=g++-8"
+      compiler: gcc-8
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-9
+      env:
+        - COMPILER="CC=gcc-9 && CXX=g++-9"
+      compiler: gcc-9
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-10
+      env:
+        - COMPILER="CC=gcc-10 && CXX=g++-10"
+      compiler: gcc-10
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-10
+      env:
+        - COMPILER="CC=gcc-10 && CXX=g++-10"
+        - SANITIZE="on"
+      compiler: gcc-10-sanitize
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-10
+      env:
+        - COMPILER="CC=gcc-10 && CXX=g++-10"
+        - STATIC="on"
+      compiler: gcc-10-static
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-6.0
+          packages:
+            - clang-6.0
+      env:
+        - COMPILER="CC=clang-6.0 && CXX=clang++-6.0"
+      compiler: clang-6
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-7
+          packages:
+            - clang-7
+      env:
+        - COMPILER="CC=clang-7 && CXX=clang++-7"
+      compiler: clang-7
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-8
+          packages:
+            - clang-8
+      env:
+        - COMPILER="CC=clang-8 && CXX=clang++-8"
+      compiler: clang-8
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-9
+          packages:
+            - clang-9
+      env:
+        - COMPILER="CC=clang-9 && CXX=clang++-9"
+      compiler: clang-9
+
+    - os: linux
+      addons:
+        apt:
+          packages:
+            - clang-10
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+      env:
+        - COMPILER="CC=clang-10 && CXX=clang++-10"
+      compiler: clang-10
+
+    - os: linux
+      addons:
+        apt:
+          packages:
+            - clang-10
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+      env:
+        - COMPILER="CC=clang-10 && CXX=clang++-10"
+        - STATIC="on"
+      compiler: clang-10-static
+
+    - os: linux
+      addons:
+        apt:
+          packages:
+            - clang-10
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+      env:
+        - COMPILER="CC=clang-10 && CXX=clang++-10"
+        - SANITIZE="on"
+      compiler: clang-10-sanitize
+
+before_install:
+  - eval "${COMPILER}"
+
+install:
+  - wget -q -O - "https://raw.githubusercontent.com/simdjson/debian-ppa/master/key.gpg" | sudo apt-key add -
+  - sudo apt-add-repository "deb https://raw.githubusercontent.com/simdjson/debian-ppa/master simdjson main"
+  - sudo apt-get -qq update
+  - sudo apt-get purge cmake cmake-data
+  - sudo apt-get -t simdjson -y install cmake
+  - export CMAKE_CXX_FLAGS="-maltivec -mcpu=power9 -mtune=power9"
+  - export CMAKE_C_FLAGS="${CMAKE_CXX_FLAGS}"
+  - export CMAKE_FLAGS="-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS} -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} -DSIMDJSON_IMPLEMENTATION=ppc64;fallback";
+  - if [[ "${SANITIZE}" == "on" ]]; then
+      export CMAKE_FLAGS="${CMAKE_FLAGS} -DSIMDJSON_SANITIZE=ON";
+      export ASAN_OPTIONS="detect_leaks=0";
+    fi
+  - if [[ "${STATIC}" == "on" ]]; then
+      export CMAKE_FLAGS="${CMAKE_FLAGS} -DSIMDJSON_BUILD_STATIC=ON";
+    fi
+  - export CTEST_FLAGS="-j4 --output-on-failure -E checkperf"
+
+script:
+  - mkdir build
+  - cd build
+  - cmake $CMAKE_FLAGS ..
+  - cmake --build . -- -j2
+  - SIMDJSON_FORCE_IMPLEMENTATION=ppc64 ctest $CTEST_FLAGS -L per_implementation
+  - SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation
+  - ctest $CTEST_FLAGS -LE "acceptance|per_implementation"
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.9) # CMP0069 NEW
+cmake_minimum_required(VERSION 3.13)

 project(simdjson
  DESCRIPTION "Parsing gigabytes of JSON per second"
@@ -6,11 +6,11 @@ project(simdjson
 )

 set(PROJECT_VERSION_MAJOR 0)
-set(PROJECT_VERSION_MINOR 5)
-set(PROJECT_VERSION_PATCH 0)
-set(SIMDJSON_SEMANTIC_VERSION "0.5.0" CACHE STRING "simdjson semantic version")
-set(SIMDJSON_LIB_VERSION "3.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "3" CACHE STRING "simdjson library soversion")
+set(PROJECT_VERSION_MINOR 7)
+set(PROJECT_VERSION_PATCH 1)
+set(SIMDJSON_SEMANTIC_VERSION "0.7.1" CACHE STRING "simdjson semantic version")
+set(SIMDJSON_LIB_VERSION "5.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "5" CACHE STRING "simdjson library soversion")
 set(SIMDJSON_GITHUB_REPOSITORY https://github.com/simdjson/simdjson)

 include(GNUInstallDirs)
@@ -21,20 +21,15 @@ include(cmake/simdjson-user-cmakecache.cmake)

 if(SIMDJSON_JUST_LIBRARY)
  message( STATUS "Building just the library, omitting all tests, tools and benchmarks." )
-endif()
-
-#
-# Set up test data
-#
-if(NOT(SIMDJSON_JUST_LIBRARY))
+else(SIMDJSON_JUST_LIBRARY)
+  # Setup tests
  enable_testing()
  add_subdirectory(jsonchecker)
  add_subdirectory(jsonexamples)
  add_library(test-data INTERFACE)
  target_link_libraries(test-data INTERFACE jsonchecker-data jsonchecker-minefield-data jsonexamples-data)
-endif()
+endif(SIMDJSON_JUST_LIBRARY)

-#
 # Create the top level simdjson library (must be done at this level to use both src/ and include/
 # directories) and tools
 #
@@ -42,6 +42,7 @@ We have few hard rules, but we have some:
 - Calls to `abort()` are forbidden in the core library. This follows from the [Writing R Extensions](https://cran.r-project.org/doc/manuals/R-exts.html) manual which states that "Under no circumstances should your compiled code ever call abort or exit".
 - All source code files (.h, .cpp) must be ASCII.
 - All C macros introduced in public headers need to be prefixed with either `SIMDJSON_` or `simdjson_`.
+- We avoid trailing white space characters within lines. That is, your lines of code should not terminate with unnecessary spaces. Generally, please avoid making unnecessary changes to white-space characters when contributing code.

 Tools, tests and benchmarks are not held to these same strict rules.

@@ -35,5 +35,6 @@ Matjaž Ostroveršnik
 Nong Li
 Furkan Taşkale
 Brendan Knapp
+Danila Kutenin
 # if you have contributed to the project and your name does not 
 # appear in this list, please let us know!
@@ -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         = "0.5.0"
+PROJECT_NUMBER         = "0.7.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
@@ -48,7 +48,7 @@ simdjson's source structure, from the top level, looks like this:
  implementations).
  * simdjson.cpp: A "main source" that includes all implementation files from src/. This is
    equivalent to the distributed simdjson.cpp.
-  * arm64/|fallback/|haswell/|westmere/: Architecture-specific implementations. All functions are
+  * arm64/|fallback/|haswell/|ppc64/|westmere/: Architecture-specific implementations. All functions are
    Each architecture defines its own namespace, e.g. simdjson::haswell.
  * generic/: Generic implementations of the simdjson parser. These files may be included and
    compiled multiple times, from whichever architectures use them. They assume they are already
@@ -67,7 +67,7 @@ Other important files and directories:
 * **.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.sh:** Generates `singleheader/simdjson.h` and `singleheader/simdjson.cpp` for release (bash script). 
+* **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, unnnecessary system calls. We recommend checking the performance as follows:
@@ -169,12 +169,13 @@ systematically regenerated on releases. To ensure you have the latest code, you
 mkdir build
 cd build
 cmake ..
+cmake --build . # needed, because currently dependencies do not work fully for the amalgamate target
 cmake --build . --target amalgamate
 ```

-You need to have a working bash on your system.
+You need to have python3 installed on your system.

-The amalgamator script is `amalgamate.sh` generates singleheader/simdjson.h by
+The amalgamator script `amalgamate.py` generates singleheader/simdjson.h by
 reading through include/simdjson.h, copy/pasting each header file into the amalgamated file at the
 point it gets included (but only once per header). singleheader/simdjson.cpp is generated from
 src/simdjson.cpp the same way, except files under generic/ may be included and copy/pasted multiple
@@ -251,7 +252,7 @@ We assume you have a common 64-bit Windows PC with at least Visual Studio 2019.
 - Install [CMake](https://cmake.org/download/). When you install it, make sure to ask that `cmake` be made available from the command line. Please choose a recent version of cmake.
 - Create a subdirectory within simdjson, such as `build`.
 - Using a shell, go to this newly created directory. You can start a shell directly from GitHub Desktop (Repository > Open in Command Prompt).
- Type `cmake  ..` in the shell while in the `build` repository. 
+- Type `cmake  ..` in the shell while in the `build` repository.
 - This last command (`cmake ...`) created a Visual Studio solution file in the newly created directory (e.g., `simdjson.sln`). Open this file in Visual Studio. You should now be able to build the project and run the tests. For example, in the `Solution Explorer` window (available from the `View` menu), right-click `ALL_BUILD` and select `Build`. To test the code, still in the `Solution Explorer` window, select `RUN_TESTS` and select `Build`.


@@ -3,7 +3,7 @@
 [![Ubuntu 20.04 CI](https://github.com/simdjson/simdjson/workflows/Ubuntu%2020.04%20CI%20(GCC%209)/badge.svg)](https://simdjson.org/plots.html)
 ![VS16-CI](https://github.com/simdjson/simdjson/workflows/VS16-CI/badge.svg)
 ![MinGW64-CI](https://github.com/simdjson/simdjson/workflows/MinGW64-CI/badge.svg)
-[![][license img]][license]  [![Doxygen Documentation](https://img.shields.io/badge/docs-doxygen-green.svg)](https://simdjson.org/api/0.5.0/index.html)
+[![][license img]][license]  [![Doxygen Documentation](https://img.shields.io/badge/docs-doxygen-green.svg)](https://simdjson.org/api/0.7.0/index.html)

 simdjson : Parsing gigabytes of JSON per second
 ===============================================
@@ -11,13 +11,16 @@ simdjson : Parsing gigabytes of JSON per second
 <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 2.5x faster than anything else out there.
+to parse JSON 2.5x  faster than RapidJSON and 25x faster than JSON for Modern C++.

-* **Fast:** Over 2.5x faster than other production-grade JSON parsers.
-* **Easy:** First-class, easy to use API.
+* **Fast:** Over 2.5x faster than commonly used production-grade JSON parsers.
+* **Record Breaking Features:** Minify JSON  at 6 GB/s, validate UTF-8  at 13 GB/s,  NDJSON at 3.5 GB/s.
+* **Easy:** First-class, easy to use and carefully documented APIs.
+* **Beyond DOM:** Try the new On Demand API for twice the speed (>4GB/s).
 * **Strict:** Full JSON and UTF-8 validation, lossless parsing. Performance with no compromises.
 * **Automatic:** Selects a CPU-tailored parser at runtime. No configuration needed.
 * **Reliable:** From memory allocation to error handling, simdjson's design avoids surprises.
+* **Peer Reviewed:** Our research appears in venues like VLDB Journal, Software: Practice and Experience.

 This library is part of the [Awesome Modern C++](https://awesomecpp.com) list.

@@ -37,10 +40,10 @@ Table of Contents
 Quick Start
 -----------

-          
+
 The simdjson library is easily consumable with a single .h and .cpp file.

-0. Prerequisites: `g++` (version 7 or better) or `clang++` (version 6 or better), and a 64-bit system with a command-line shell (e.g., Linux, macOS, freeBSD). We also support programming environnements like Visual Studio and Xcode, but different steps are needed.
+0. Prerequisites: `g++` (version 7 or better) or `clang++` (version 6 or better), and a 64-bit system with a command-line shell (e.g., Linux, macOS, freeBSD). We also support programming environments like Visual Studio and Xcode, but different steps are needed.
 1. Pull [simdjson.h](singleheader/simdjson.h) and [simdjson.cpp](singleheader/simdjson.cpp) into a directory, along with the sample file [twitter.json](jsonexamples/twitter.json).
   ```
   wget https://raw.githubusercontent.com/simdjson/simdjson/master/singleheader/simdjson.h https://raw.githubusercontent.com/simdjson/simdjson/master/singleheader/simdjson.cpp https://raw.githubusercontent.com/simdjson/simdjson/master/jsonexamples/twitter.json
@@ -70,7 +73,7 @@ Usage documentation is available:
 * [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.org/api/0.5.0/annotated.html) contains the automatically generated API documentation.
+* [API](https://simdjson.org/api/0.7.0/annotated.html) contains the automatically generated API documentation.

 Performance results
 -------------------
@@ -119,9 +122,14 @@ or larger files (e.g., 3MB). The following plot presents parsing
 speed for [synthetic files over various sizes generated with a script](https://github.com/simdjson/simdjson_experiments_vldb2019/blob/master/experiments/growing/gen.py) on a 3.4 GHz Skylake processor (GNU GCC 9, -O3).
 <img src="doc/growing.png" width="90%">

-
 [All our experiments are reproducible](https://github.com/simdjson/simdjson_experiments_vldb2019).

+
+You can go beyond 4 GB/s with our new [On Demand API](https://github.com/simdjson/simdjson/blob/master/doc/ondemand.md).
+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).
+
+
+
 Real-world usage
 ----------------

@@ -149,6 +157,8 @@ We distinguish between "bindings" (which just wrap the C++ code) and a port to a
 - [fast_jsonparser](https://github.com/anilmaurya/fast_jsonparser): Ruby bindings for the simdjson project.
 - [simdjson-go](https://github.com/minio/simdjson-go): Go port using Golang assembly.
 - [rcppsimdjson](https://github.com/eddelbuettel/rcppsimdjson): R bindings.
+- [simdjson_erlang](https://github.com/ChomperT/simdjson_erlang): erlang bindings.
+

 About simdjson
 --------------
@@ -158,8 +168,12 @@ instructions, reducing branch misprediction, and reducing data dependency to tak
 CPU's multiple execution cores.

 Some people [enjoy reading our paper](https://arxiv.org/abs/1902.08318): A description of the design
-and implementation of simdjson is in our research article: Geoff Langdale, Daniel
-Lemire, [Parsing Gigabytes of JSON per Second](https://arxiv.org/abs/1902.08318), VLDB Journal 28 (6), 2019.
+and implementation of simdjson is in our research article:
+- Geoff Langdale, Daniel Lemire, [Parsing Gigabytes of JSON per Second](https://arxiv.org/abs/1902.08318), VLDB Journal 28 (6), 2019.
+
+We have an in-depth paper focused on the UTF-8 validation:
+
+- John Keiser, Daniel Lemire, [Validating UTF-8 In Less Than One Instruction Per Byte](https://arxiv.org/abs/2010.03090), Software: Practice & Experience (to appear)

 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/).

@@ -4,7 +4,7 @@ link_libraries(simdjson-windows-headers test-data)

 if (TARGET benchmark::benchmark)
  add_executable(bench_sax bench_sax.cpp)
-  target_link_libraries(bench_sax simdjson-internal-flags simdjson-include-source benchmark::benchmark)
+  target_link_libraries(bench_sax PRIVATE simdjson-internal-flags simdjson-include-source benchmark::benchmark)
 endif (TARGET benchmark::benchmark)

 link_libraries(simdjson simdjson-flags)
@@ -24,15 +24,19 @@ target_compile_definitions(parse_nostringparsing PRIVATE SIMDJSON_SKIPSTRINGPARS

 if (TARGET competition-all)
  add_executable(distinctuseridcompetition distinctuseridcompetition.cpp)
-  target_link_libraries(distinctuseridcompetition competition-core)
+  target_link_libraries(distinctuseridcompetition PRIVATE competition-core)
+
  add_executable(minifiercompetition minifiercompetition.cpp)
-  target_link_libraries(minifiercompetition competition-core)
+  target_link_libraries(minifiercompetition PRIVATE competition-core)
+
  add_executable(parseandstatcompetition parseandstatcompetition.cpp)
-  target_link_libraries(parseandstatcompetition competition-core)
+  target_link_libraries(parseandstatcompetition PRIVATE competition-core)
+
  add_executable(parsingcompetition parsingcompetition.cpp)
-  target_link_libraries(parsingcompetition competition-core)
+  target_link_libraries(parsingcompetition PRIVATE competition-core)
+
  add_executable(allparsingcompetition parsingcompetition.cpp)
-  target_link_libraries(allparsingcompetition competition-all)
+  target_link_libraries(allparsingcompetition PRIVATE competition-all)
  target_compile_definitions(allparsingcompetition PRIVATE ALLPARSER)
 endif()

@@ -40,6 +44,7 @@ if (TARGET benchmark::benchmark)
  link_libraries(benchmark::benchmark)
  add_executable(bench_parse_call bench_parse_call.cpp)
  add_executable(bench_dom_api bench_dom_api.cpp)
+  add_executable(bench_ondemand bench_ondemand.cpp)
 endif()

 include(checkperf.cmake)
@@ -8,8 +8,8 @@ using namespace std;

 const padded_string EMPTY_ARRAY("[]", 2);

-const char *TWITTER_JSON = SIMDJSON_BENCHMARK_DATA_DIR "twitter.json";
-const char *NUMBERS_JSON = SIMDJSON_BENCHMARK_DATA_DIR "numbers.json";
+static const char *TWITTER_JSON = SIMDJSON_BENCHMARK_DATA_DIR "twitter.json";
+static const char *NUMBERS_JSON = SIMDJSON_BENCHMARK_DATA_DIR "numbers.json";

 static void recover_one_string(State& state) {
  dom::parser parser;
@@ -26,7 +26,7 @@ static void recover_one_string(State& state) {
    cerr << "could not parse string" << error << endl;
    return;
  }
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
      std::string_view v;
      error = doc.get(v);
      if (error) {
@@ -58,21 +58,141 @@ static void serialize_twitter(State& state) {
    return;
  }
  size_t bytes = 0;
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    std::string serial = simdjson::minify(doc);
    bytes += serial.size();
    benchmark::DoNotOptimize(serial);
  }
+  // we validate the result
+  {
+    auto serial = simdjson::minify(doc);
+    dom::element doc2; // we parse the minified output
+    if ((error = parser.parse(serial).get(doc2))) { throw std::runtime_error("serialization error"); }
+    auto serial2 = simdjson::minify(doc2); // we minify a second time
+    if(serial != serial2) { throw std::runtime_error("serialization mismatch"); }
+  }
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+  state.counters["Gigabytes"] = benchmark::Counter(
+	        double(bytes), benchmark::Counter::kIsRate,
+	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
+  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
+}
+BENCHMARK(serialize_twitter)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+
+static void serialize_big_string_to_string(State& state) {
+  dom::parser parser;
+  std::vector<char> content;
+  content.push_back('\"');
+  for(size_t i = 0 ; i < 100000; i ++) {
+    content.push_back('0' + char(i%10)); // we add what looks like a long list of digits
+  }
+  content.push_back('\"');
+  dom::element doc;
+  simdjson::error_code error;
+  if ((error = parser.parse(content.data(), content.size()).get(doc))) {
+    cerr << "could not parse big string" << error << endl;
+    return;
+  }
+  size_t bytes = 0;
+  for (simdjson_unused auto _ : state) {
+    auto serial = simdjson::to_string(doc);
+    bytes += serial.size();
+    benchmark::DoNotOptimize(serial);
+  }
  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
  state.counters["Gigabytes"] = benchmark::Counter(
 	        double(bytes), benchmark::Counter::kIsRate,
 	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
 }
-BENCHMARK(serialize_twitter)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+BENCHMARK(serialize_big_string_to_string)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
    return *(std::max_element(std::begin(v), std::end(v)));
  })->DisplayAggregatesOnly(true);

+
+static void serialize_twitter_to_string(State& state) {
+  dom::parser parser;
+  padded_string docdata;
+  auto error = padded_string::load(TWITTER_JSON).get(docdata);
+  if(error) {
+      cerr << "could not parse twitter.json" << error << endl;
+      return;
+  }
+  // we do not want mem. alloc. in the loop.
+  if((error = parser.allocate(docdata.size()))) {
+      cout << error << endl;
+      return;
+  }
+  dom::element doc;
+  if ((error = parser.parse(docdata).get(doc))) {
+    cerr << "could not parse twitter.json" << error << endl;
+    return;
+  }
+  size_t bytes = 0;
+  for (simdjson_unused auto _ : state) {
+    auto serial = simdjson::to_string(doc);
+    bytes += serial.size();
+    benchmark::DoNotOptimize(serial);
+  }
+  // we validate the result
+  {
+    auto serial = simdjson::to_string(doc);
+    dom::element doc2; // we parse the stringify output
+    if ((error = parser.parse(serial).get(doc2))) { throw std::runtime_error("serialization error"); }
+    auto serial2 = simdjson::to_string(doc2); // we stringify again
+    if(serial != serial2) { throw std::runtime_error("serialization mismatch"); }
+  }
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+  state.counters["Gigabytes"] = benchmark::Counter(
+	        double(bytes), benchmark::Counter::kIsRate,
+	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
+  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
+}
+BENCHMARK(serialize_twitter_to_string)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+static void serialize_twitter_string_builder(State& state) {
+  dom::parser parser;
+  padded_string docdata;
+  auto error = padded_string::load(TWITTER_JSON).get(docdata);
+  if(error) {
+      cerr << "could not parse twitter.json" << error << endl;
+      return;
+  }
+  // we do not want mem. alloc. in the loop.
+  if((error = parser.allocate(docdata.size()))) {
+      cout << error << endl;
+      return;
+  }
+  dom::element doc;
+  if ((error = parser.parse(docdata).get(doc))) {
+    cerr << "could not parse twitter.json" << error << endl;
+    return;
+  }
+  size_t bytes = 0;
+  simdjson::internal::string_builder<> sb;// not part of our public API, for internal use
+  for (simdjson_unused auto _ : state) {
+    sb.clear();
+    sb.append(doc);
+    std::string_view serial = sb.str();
+    bytes += serial.size();
+    benchmark::DoNotOptimize(serial);
+  }
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+  state.counters["Gigabytes"] = benchmark::Counter(
+	        double(bytes), benchmark::Counter::kIsRate,
+	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
+  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
+}
+BENCHMARK(serialize_twitter_string_builder)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+
 static void numbers_scan(State& state) {
  // Prints the number of results in twitter.json
  dom::parser parser;
@@ -82,7 +202,7 @@ static void numbers_scan(State& state) {
    cerr << "could not read " << NUMBERS_JSON << " as an array: " << error << endl;
    return;
  }
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    std::vector<double> container;
    for (auto e : arr) {
      double x;
@@ -91,7 +211,7 @@ static void numbers_scan(State& state) {
    }
    benchmark::DoNotOptimize(container.data());
    benchmark::ClobberMemory();
-  }  
+  }
 }
 BENCHMARK(numbers_scan);

@@ -104,7 +224,7 @@ static void numbers_size_scan(State& state) {
    cerr << "could not read " << NUMBERS_JSON << " as an array: " << error << endl;
    return;
  }
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    std::vector<double> container;
    container.resize(arr.size());
    size_t pos = 0;
@@ -116,7 +236,7 @@ static void numbers_size_scan(State& state) {
    if(pos != container.size()) { cerr << "bad count" << endl; }
    benchmark::DoNotOptimize(container.data());
    benchmark::ClobberMemory();
-  }  
+  }
 }
 BENCHMARK(numbers_size_scan);

@@ -130,7 +250,7 @@ static void numbers_type_scan(State& state) {
    cerr << "could not read " << NUMBERS_JSON << " as an array" << endl;
    return;
  }
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    std::vector<double> container;
    for (auto e : arr) {
      dom::element_type actual_type = e.type();
@@ -156,7 +276,7 @@ static void numbers_type_size_scan(State& state) {
    cerr << "could not read " << NUMBERS_JSON << " as an array: " << error << endl;
    return;
  }
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    std::vector<double> container;
    container.resize(arr.size());
    size_t pos = 0;
@@ -181,7 +301,7 @@ static void numbers_load_scan(State& state) {
  dom::parser parser;
  dom::array arr;
  simdjson::error_code error;
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    // this may hit the disk, but probably just once
    if ((error = parser.load(NUMBERS_JSON).get(arr))) {
      cerr << "could not read " << NUMBERS_JSON << " as an array: " << error << endl;
@@ -195,7 +315,7 @@ static void numbers_load_scan(State& state) {
    }
    benchmark::DoNotOptimize(container.data());
    benchmark::ClobberMemory();
-  }  
+  }
 }
 BENCHMARK(numbers_load_scan);

@@ -204,7 +324,7 @@ static void numbers_load_size_scan(State& state) {
  dom::parser parser;
  dom::array arr;
  simdjson::error_code error;
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    // this may hit the disk, but probably just once
    if ((error = parser.load(NUMBERS_JSON).get(arr))) {
      cerr << "could not read " << NUMBERS_JSON << " as an array" << endl;
@@ -221,7 +341,7 @@ static void numbers_load_size_scan(State& state) {
    if(pos != container.size()) { cerr << "bad count" << endl; }
    benchmark::DoNotOptimize(container.data());
    benchmark::ClobberMemory();
-  }  
+  }
 }
 BENCHMARK(numbers_load_size_scan);

@@ -233,14 +353,14 @@ static void numbers_exceptions_scan(State& state) {
  // Prints the number of results in twitter.json
  dom::parser parser;
  dom::array arr = parser.load(NUMBERS_JSON);
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    std::vector<double> container;
    for (double x : arr) {
      container.push_back(x);
    }
    benchmark::DoNotOptimize(container.data());
    benchmark::ClobberMemory();
-  }  
+  }
 }
 BENCHMARK(numbers_exceptions_scan);

@@ -248,7 +368,7 @@ static void numbers_exceptions_size_scan(State& state) {
  // Prints the number of results in twitter.json
  dom::parser parser;
  dom::array arr = parser.load(NUMBERS_JSON);
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    std::vector<double> container;
    container.resize(arr.size());
    size_t pos = 0;
@@ -258,7 +378,7 @@ static void numbers_exceptions_size_scan(State& state) {
    if(pos != container.size()) { cerr << "bad count" << endl; }
    benchmark::DoNotOptimize(container.data());
    benchmark::ClobberMemory();
-  }  
+  }
 }
 BENCHMARK(numbers_exceptions_size_scan);

@@ -268,7 +388,7 @@ static void numbers_type_exceptions_scan(State& state) {
  // Prints the number of results in twitter.json
  dom::parser parser;
  dom::array arr = parser.load(NUMBERS_JSON);
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    std::vector<double> container;
    for (auto e : arr) {
      dom::element_type actual_type = e.type();
@@ -287,7 +407,7 @@ static void numbers_type_exceptions_size_scan(State& state) {
  // Prints the number of results in twitter.json
  dom::parser parser;
  dom::array arr = parser.load(NUMBERS_JSON);
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    std::vector<double> container;
    container.resize(arr.size());
    size_t pos = 0;
@@ -308,7 +428,7 @@ BENCHMARK(numbers_type_exceptions_size_scan);
 static void numbers_exceptions_load_scan(State& state) {
  // Prints the number of results in twitter.json
  dom::parser parser;
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    // this may hit the disk, but probably just once
    dom::array arr = parser.load(NUMBERS_JSON);
    std::vector<double> container;
@@ -317,14 +437,14 @@ static void numbers_exceptions_load_scan(State& state) {
    }
    benchmark::DoNotOptimize(container.data());
    benchmark::ClobberMemory();
-  }  
+  }
 }
 BENCHMARK(numbers_exceptions_load_scan);

 static void numbers_exceptions_load_size_scan(State& state) {
  // Prints the number of results in twitter.json
  dom::parser parser;
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    // this may hit the disk, but probably just once
    dom::array arr = parser.load(NUMBERS_JSON);
    std::vector<double> container;
@@ -336,7 +456,7 @@ static void numbers_exceptions_load_size_scan(State& state) {
    if(pos != container.size()) { cerr << "bad count" << endl; }
    benchmark::DoNotOptimize(container.data());
    benchmark::ClobberMemory();
-  }  
+  }
 }
 BENCHMARK(numbers_exceptions_load_size_scan);

@@ -345,20 +465,21 @@ static void twitter_count(State& state) {
  // Prints the number of results in twitter.json
  dom::parser parser;
  dom::element doc = parser.load(TWITTER_JSON);
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    uint64_t result_count = doc["search_metadata"]["count"];
    if (result_count != 100) { return; }
  }
 }
 BENCHMARK(twitter_count);

+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
 SIMDJSON_PUSH_DISABLE_WARNINGS
 SIMDJSON_DISABLE_DEPRECATED_WARNING
 static void iterator_twitter_count(State& state) {
  // Prints the number of results in twitter.json
  padded_string json = padded_string::load(TWITTER_JSON);
  ParsedJson pj = build_parsed_json(json);
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    ParsedJson::Iterator iter(pj);
    // uint64_t result_count = doc["search_metadata"]["count"];
    if (!iter.move_to_key("search_metadata")) { return; }
@@ -371,12 +492,13 @@ static void iterator_twitter_count(State& state) {
 }
 BENCHMARK(iterator_twitter_count);
 SIMDJSON_POP_DISABLE_WARNINGS
+#endif // SIMDJSON_DISABLE_DEPRECATED_API

 static void twitter_default_profile(State& state) {
  // Count unique users with a default profile.
  dom::parser parser;
  dom::element doc = parser.load(TWITTER_JSON);
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    set<string_view> default_users;
    for (dom::object tweet : doc["statuses"]) {
      dom::object user = tweet["user"];
@@ -394,7 +516,7 @@ static void twitter_image_sizes(State& state) {
  dom::parser parser;
  dom::element doc = parser.load(TWITTER_JSON);
  simdjson::error_code error;
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    set<tuple<uint64_t, uint64_t>> image_sizes;
    for (dom::object tweet : doc["statuses"]) {
      dom::array media;
@@ -419,7 +541,7 @@ static void error_code_twitter_count(State& state) noexcept {
  simdjson::error_code error;
  dom::element doc;
  if ((error = parser.load(TWITTER_JSON).get(doc))) { return; }
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    uint64_t value;
    if ((error = doc["search_metadata"]["count"].get(value))) { return; }
    if (value != 100) { return; }
@@ -433,7 +555,7 @@ static void error_code_twitter_default_profile(State& state) noexcept {
  simdjson::error_code error;
  dom::element doc;
  if ((error = parser.load(TWITTER_JSON).get(doc))) { std::cerr << error << std::endl; return; }
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    set<string_view> default_users;

    dom::array tweets;
@@ -455,15 +577,18 @@ static void error_code_twitter_default_profile(State& state) noexcept {
 }
 BENCHMARK(error_code_twitter_default_profile);

+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
+
 SIMDJSON_PUSH_DISABLE_WARNINGS
 SIMDJSON_DISABLE_DEPRECATED_WARNING
+
 static void iterator_twitter_default_profile(State& state) {
  // Count unique users with a default profile.
  padded_string json;
  auto error = padded_string::load(TWITTER_JSON).get(json);
  if (error) { std::cerr << error << std::endl; return; }
  ParsedJson pj = build_parsed_json(json);
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    set<string_view> default_users;
    ParsedJson::Iterator iter(pj);

@@ -495,8 +620,10 @@ static void iterator_twitter_default_profile(State& state) {
    if (default_users.size() != 86) { return; }
  }
 }
+
 SIMDJSON_POP_DISABLE_WARNINGS
 BENCHMARK(iterator_twitter_default_profile);
+#endif // SIMDJSON_DISABLE_DEPRECATED_API

 static void error_code_twitter_image_sizes(State& state) noexcept {
  // Count unique image sizes
@@ -504,7 +631,7 @@ static void error_code_twitter_image_sizes(State& state) noexcept {
  simdjson::error_code error;
  dom::element doc;
  if ((error = parser.load(TWITTER_JSON).get(doc))) { std::cerr << error << std::endl; return; }
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    set<tuple<uint64_t, uint64_t>> image_sizes;
    dom::array statuses;
    if ((error = doc["statuses"].get(statuses))) { return; }
@@ -528,6 +655,8 @@ static void error_code_twitter_image_sizes(State& state) noexcept {
 }
 BENCHMARK(error_code_twitter_image_sizes);

+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
+
 SIMDJSON_PUSH_DISABLE_WARNINGS
 SIMDJSON_DISABLE_DEPRECATED_WARNING
 static void iterator_twitter_image_sizes(State& state) {
@@ -536,7 +665,7 @@ static void iterator_twitter_image_sizes(State& state) {
  auto error = padded_string::load(TWITTER_JSON).get(json);
  if (error) { std::cerr << error << std::endl; return; }
  ParsedJson pj = build_parsed_json(json);
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    set<tuple<uint64_t, uint64_t>> image_sizes;
    ParsedJson::Iterator iter(pj);

@@ -582,7 +711,7 @@ static void iterator_twitter_image_sizes(State& state) {
            if (!iter.up()) { return; } // back to entities
          }
          if (!iter.up()) { return; } // back to status
-        } 
+        }
      } while (iter.next()); // next status
    }

@@ -591,6 +720,9 @@ static void iterator_twitter_image_sizes(State& state) {
 }
 BENCHMARK(iterator_twitter_image_sizes);

+#endif // SIMDJSON_DISABLE_DEPRECATED_API
+
+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
 static void print_json(State& state) noexcept {
  // Prints the number of results in twitter.json
  dom::parser parser;
@@ -601,12 +733,13 @@ static void print_json(State& state) noexcept {

  int code = json_parse(json, parser);
  if (code) { cerr << error_message(code) << endl; return; }
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    std::stringstream s;
    if (!parser.print_json(s)) { cerr << "print_json failed" << endl; return; }
  }
 }
 BENCHMARK(print_json);
+#endif // SIMDJSON_DISABLE_DEPRECATED_API
 SIMDJSON_POP_DISABLE_WARNINGS

-BENCHMARK_MAIN();
+BENCHMARK_MAIN();
@@ -0,0 +1,26 @@
+#include "simdjson.h"
+#include <iostream>
+#include <sstream>
+#include <random>
+#include <vector>
+SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
+#include <benchmark/benchmark.h>
+SIMDJSON_POP_DISABLE_WARNINGS
+
+#include "partial_tweets/ondemand.h"
+#include "partial_tweets/iter.h"
+#include "partial_tweets/dom.h"
+
+#include "largerandom/ondemand.h"
+#include "largerandom/iter.h"
+#include "largerandom/dom.h"
+
+#include "kostya/ondemand.h"
+#include "kostya/iter.h"
+#include "kostya/dom.h"
+
+#include "distinctuserid/ondemand.h"
+#include "distinctuserid/dom.h"
+
+
+BENCHMARK_MAIN();
@@ -25,7 +25,7 @@ static void unicode_validate_twitter(State& state) {
      return;
  }
  size_t bytes = 0;
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    bool is_ok = simdjson::validate_utf8(docdata.data(), docdata.size());
    bytes += docdata.size();
    benchmark::DoNotOptimize(is_ok);
@@ -55,7 +55,7 @@ static void parse_twitter(State& state) {
      return;
  }
  size_t bytes = 0;
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    dom::element doc;
    bytes += docdata.size();
    if ((error = parser.parse(docdata).get(doc))) {
@@ -90,7 +90,7 @@ static void parse_gsoc(State& state) {
      return;
  }
  size_t bytes = 0;
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    bytes += docdata.size();
    dom::element doc;
    if ((error = parser.parse(docdata).get(doc))) {
@@ -111,22 +111,25 @@ BENCHMARK(parse_gsoc)->Repetitions(10)->ComputeStatistics("max", [](const std::v



+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
 SIMDJSON_PUSH_DISABLE_WARNINGS
 SIMDJSON_DISABLE_DEPRECATED_WARNING
 static void json_parse(State& state) {
  ParsedJson pj;
  if (!pj.allocate_capacity(EMPTY_ARRAY.length())) { return; }
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    auto error = json_parse(EMPTY_ARRAY, pj);
    if (error) { return; }
  }
 }
 SIMDJSON_POP_DISABLE_WARNINGS
 BENCHMARK(json_parse);
+#endif // SIMDJSON_DISABLE_DEPRECATED_API
+
 static void parser_parse_error_code(State& state) {
  dom::parser parser;
  if (parser.allocate(EMPTY_ARRAY.length())) { return; }
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    auto error = parser.parse(EMPTY_ARRAY).error();
    if (error) { return; }
  }
@@ -138,9 +141,9 @@ BENCHMARK(parser_parse_error_code);
 static void parser_parse_exception(State& state) {
  dom::parser parser;
  if (parser.allocate(EMPTY_ARRAY.length())) { return; }
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    try {
-      SIMDJSON_UNUSED dom::element doc = parser.parse(EMPTY_ARRAY);
+      simdjson_unused dom::element doc = parser.parse(EMPTY_ARRAY);
    } catch(simdjson_error &j) {
      cout << j.what() << endl;
      return;
@@ -151,10 +154,11 @@ BENCHMARK(parser_parse_exception);

 #endif // SIMDJSON_EXCEPTIONS

+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
 SIMDJSON_PUSH_DISABLE_WARNINGS
 SIMDJSON_DISABLE_DEPRECATED_WARNING
 static void build_parsed_json(State& state) {
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    dom::parser parser = simdjson::build_parsed_json(EMPTY_ARRAY);
    if (!parser.valid) { return; }
  }
@@ -162,8 +166,10 @@ static void build_parsed_json(State& state) {
 SIMDJSON_POP_DISABLE_WARNINGS

 BENCHMARK(build_parsed_json);
+#endif
+
 static void document_parse_error_code(State& state) {
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    dom::parser parser;
    auto error = parser.parse(EMPTY_ARRAY).error();
    if (error) { return; }
@@ -174,10 +180,10 @@ BENCHMARK(document_parse_error_code);
 #if SIMDJSON_EXCEPTIONS

 static void document_parse_exception(State& state) {
-  for (SIMDJSON_UNUSED auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    try {
      dom::parser parser;
-      SIMDJSON_UNUSED dom::element doc = parser.parse(EMPTY_ARRAY);
+      simdjson_unused dom::element doc = parser.parse(EMPTY_ARRAY);
    } catch(simdjson_error &j) {
      cout << j.what() << endl;
      return;
@@ -1,359 +1,14 @@
-#define SIMDJSON_IMPLEMENTATION_FALLBACK 0
-#define SIMDJSON_IMPLEMENTATION_WESTMERE 0
-#define SIMDJSON_IMPLEMENTATION_AMD64 0
-
+#include "simdjson.h"
+#include "simdjson.cpp"
 #include <iostream>
 #include <sstream>
 #include <random>
-
-#include "simdjson.h"
-
+#include <vector>
 SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
 #include <benchmark/benchmark.h>
 SIMDJSON_POP_DISABLE_WARNINGS

-#include "simdjson.cpp"
-
-#if SIMDJSON_EXCEPTIONS
-
-using namespace benchmark;
-using namespace simdjson;
-using std::cerr;
-using std::endl;
-
-const char *TWITTER_JSON = SIMDJSON_BENCHMARK_DATA_DIR "twitter.json";
-const int REPETITIONS = 10;
-
-#if SIMDJSON_IMPLEMENTATION_HASWELL
-
-#include "twitter/sax_tweet_reader.h"
-
-static void sax_tweets(State &state) {
-  // Load twitter.json to a buffer
-  padded_string json;
-  if (auto error = padded_string::load(TWITTER_JSON).get(json)) { cerr << error << endl; return; }
-
-  // Allocate
-  twitter::sax_tweet_reader reader;
-  if (auto error = reader.set_capacity(json.size())) { cerr << error << endl; return; }
-
-  // Warm the vector
-  if (auto error = reader.read_tweets(json)) { throw error; }
-
-  // Read tweets
-  size_t bytes = 0;
-  size_t tweets = 0;
-  for (SIMDJSON_UNUSED auto _ : state) {
-    if (auto error = reader.read_tweets(json)) { throw error; }
-    bytes += json.size();
-    tweets += reader.tweets.size();
-  }
-  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
-  state.counters["Gigabytes"] = benchmark::Counter(
-	        double(bytes), benchmark::Counter::kIsRate,
-	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
-  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
-  state.counters["tweets"] = Counter(double(tweets), benchmark::Counter::kIsRate);
-}
-BENCHMARK(sax_tweets)->Repetitions(REPETITIONS)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
-    return *(std::max_element(std::begin(v), std::end(v)));
-  })->DisplayAggregatesOnly(true);
-
-#endif // SIMDJSON_IMPLEMENTATION_HASWELL
-
-#include "twitter/tweet.h"
-
-simdjson_really_inline uint64_t nullable_int(dom::element element) {
-  if (element.is_null()) { return 0; }
-  return element;
-}
-simdjson_really_inline void read_dom_tweets(dom::parser &parser, padded_string &json, std::vector<twitter::tweet> &tweets) {
-  for (dom::element tweet : parser.parse(json)["statuses"]) {
-    auto user = tweet["user"];
-    tweets.push_back(
-      {
-        tweet["id"],
-        tweet["text"],
-        tweet["created_at"],
-        nullable_int(tweet["in_reply_to_status_id"]),
-        tweet["retweet_count"],
-        tweet["favorite_count"],
-        { user["id"], user["screen_name"] }
-      }
-    );
-  }
-}
-
-static void dom_tweets(State &state) {
-  // Load twitter.json to a buffer
-  padded_string json;
-  if (auto error = padded_string::load(TWITTER_JSON).get(json)) { cerr << error << endl; return; }
-
-  // Allocate
-  dom::parser parser;
-  if (auto error = parser.allocate(json.size())) { cerr << error << endl; return; };
-
-  // Warm the vector
-  std::vector<twitter::tweet> tweets;
-  read_dom_tweets(parser, json, tweets);
-
-  // Read tweets
-  size_t bytes = 0;
-  size_t num_tweets = 0;
-  for (SIMDJSON_UNUSED auto _ : state) {
-    tweets.clear();
-    read_dom_tweets(parser, json, tweets);
-    bytes += json.size();
-    num_tweets += tweets.size();
-  }
-  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
-  state.counters["Gigabytes"] = benchmark::Counter(
-	        double(bytes), benchmark::Counter::kIsRate,
-	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
-  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
-  state.counters["tweets"] = Counter(double(num_tweets), benchmark::Counter::kIsRate);
-}
-BENCHMARK(dom_tweets)->Repetitions(REPETITIONS)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
-    return *(std::max_element(std::begin(v), std::end(v)));
-  })->DisplayAggregatesOnly(true);
-
-static void dom_parse(State &state) {
-  // Load twitter.json to a buffer
-  padded_string json;
-  if (auto error = padded_string::load(TWITTER_JSON).get(json)) { cerr << error << endl; return; }
-
-  // Allocate
-  dom::parser parser;
-  if (auto error = parser.allocate(json.size())) { cerr << error << endl; return; };
-
-  // Read tweets
-  size_t bytes = 0;
-  for (SIMDJSON_UNUSED auto _ : state) {
-    if (parser.parse(json).error()) { throw "Parsing failed"; };
-    bytes += json.size();
-  }
-  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
-  state.counters["Gigabytes"] = benchmark::Counter(
-	        double(bytes), benchmark::Counter::kIsRate,
-	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
-  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
-}
-BENCHMARK(dom_parse)->Repetitions(REPETITIONS)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
-    return *(std::max_element(std::begin(v), std::end(v)));
-  })->DisplayAggregatesOnly(true);
-
-
-/********************
- * Large file parsing benchmarks:
- ********************/
-
-static std::string build_json_array(size_t N) {
-  std::default_random_engine e;
-  std::uniform_real_distribution<> dis(0, 1);
-  std::stringstream myss;
-  myss << "[" << std::endl;
-  if(N > 0) {
-    myss << "{ \"x\":" << dis(e) << ",  \"y\":" << dis(e) << ", \"z\":" << dis(e) << "}" << std::endl;
-  }
-  for(size_t i = 1; i < N; i++) {
-    myss << "," << std::endl;
-    myss << "{ \"x\":" << dis(e) << ",  \"y\":" << dis(e) << ", \"z\":" << dis(e) << "}";
-  }
-  myss << std::endl;
-  myss << "]" << std::endl;
-  std::string answer = myss.str();
-  std::cout << "Creating a source file spanning " << (answer.size() + 512) / 1024 << " KB " << std::endl;  
-  return answer;
-}
-
-static const simdjson::padded_string& get_my_json_str() {
-  static simdjson::padded_string s = build_json_array(1000000);
-  return s;
-}
-
-struct my_point {
-  double x;
-  double y;
-  double z;
-};
-
-// ./benchmark/bench_sax --benchmark_filter=largerandom
-
-
-/*** 
- * We start with the naive DOM-based approach.
- **/
-static void dom_parse_largerandom(State &state) {
-  // Load twitter.json to a buffer
-  const padded_string& json = get_my_json_str();
-
-  // Allocate
-  dom::parser parser;
-  if (auto error = parser.allocate(json.size())) { cerr << error << endl; return; };
-
-  // Read
-  size_t bytes = 0;
-  simdjson::error_code error;
-  for (SIMDJSON_UNUSED auto _ : state) {
-    std::vector<my_point> container;
-    dom::element doc;
-    if ((error = parser.parse(json).get(doc))) { 
-      std::cerr << "failure: " << error << std::endl;
-      throw "Parsing failed"; 
-    };
-    for (auto p : doc) {
-      container.emplace_back(my_point{p["x"], p["y"], p["z"]});
-    }
-    bytes += json.size();
-    benchmark::DoNotOptimize(container.data());
-
-  }
-  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
-  state.counters["Gigabytes"] = benchmark::Counter(
-	        double(bytes), benchmark::Counter::kIsRate,
-	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
-  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
-}
-
-BENCHMARK(dom_parse_largerandom)->Repetitions(REPETITIONS)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
-    return *(std::max_element(std::begin(v), std::end(v)));
-  })->DisplayAggregatesOnly(true);
-
-#if SIMDJSON_IMPLEMENTATION_HASWELL
-
-/*** 
- * Next we are going to code the SAX approach.
- **/
-
-SIMDJSON_TARGET_HASWELL
-
-namespace largerandom {
-namespace {
-
-using namespace simdjson;
-using namespace haswell;
-using namespace haswell::stage2;
-struct sax_point_reader_visitor {
-public:
-  sax_point_reader_visitor(std::vector<my_point> &_points) : points(_points) {
-  }
-
-  simdjson_really_inline error_code visit_document_start(json_iterator &) { return SUCCESS; }
-  simdjson_really_inline error_code visit_object_start(json_iterator &) { return SUCCESS; }
-  simdjson_really_inline error_code visit_key(json_iterator &, const uint8_t *key) {
-    switch(key[0]) {
-      case 'x':
-        idx = 0;
-        break;
-      case 'y':
-        idx = 2;
-        break;
-      case 'z':
-        idx = 3;
-        break;  
-    }
-    return SUCCESS; 
-  }
-  simdjson_really_inline error_code visit_primitive(json_iterator &, const uint8_t *value) {
-    return numberparsing::parse_double(value).get(buffer[idx]);
-  }
-  simdjson_really_inline error_code visit_array_start(json_iterator &)  { return SUCCESS; }
-  simdjson_really_inline error_code visit_array_end(json_iterator &) { return SUCCESS; }
-  simdjson_really_inline error_code visit_object_end(json_iterator &)  { return SUCCESS; }
-  simdjson_really_inline error_code visit_document_end(json_iterator &)  { return SUCCESS; }
-  simdjson_really_inline error_code visit_empty_array(json_iterator &)  { return SUCCESS; }
-  simdjson_really_inline error_code visit_empty_object(json_iterator &)  { return SUCCESS; }
-  simdjson_really_inline error_code visit_root_primitive(json_iterator &, const uint8_t *)  { return SUCCESS; }
-  simdjson_really_inline error_code increment_count(json_iterator &) { return SUCCESS; }
-  std::vector<my_point> &points;
-  size_t idx{0};
-  double buffer[3];
-};
-
-struct sax_point_reader {
-  std::vector<my_point> points;
-  std::unique_ptr<uint8_t[]> string_buf;
-  size_t capacity;
-  dom_parser_implementation dom_parser;
-
-  sax_point_reader();
-  error_code set_capacity(size_t new_capacity);
-  error_code read_points(const padded_string &json);
-}; // struct sax_point_reader
-
-sax_point_reader::sax_point_reader() : points{}, string_buf{}, capacity{0}, dom_parser() {
-}
-
-error_code sax_point_reader::set_capacity(size_t new_capacity) {
-  // string_capacity copied from document::allocate
-  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + 32, 64);
-  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
-  if (auto error = dom_parser.set_capacity(new_capacity)) { return error; }
-  if (capacity == 0) { // set max depth the first time only
-    if (auto error = dom_parser.set_max_depth(DEFAULT_MAX_DEPTH)) { return error; }
-  }
-  capacity = new_capacity;
-  return SUCCESS;
-}
-
-error_code sax_point_reader::read_points(const padded_string &json) {
-  // Allocate capacity if needed
-  points.clear();
-  if (capacity < json.size()) {
-    if (auto error = set_capacity(capacity)) { return error; }
-  }
-
-  // Run stage 1 first.
-  if (auto error = dom_parser.stage1((uint8_t *)json.data(), json.size(), false)) { return error; }
-
-  // Then walk the document, parsing the tweets as we go
-  json_iterator iter(dom_parser, 0);
-  sax_point_reader_visitor visitor(points);
-  if (auto error = iter.walk_document<false>(visitor)) { return error; }
-  return SUCCESS;
-}
-
-} // unnamed namespace
-} // namespace largerandom
-
-SIMDJSON_UNTARGET_REGION
-
-
-
-
-
-// ./benchmark/bench_sax --benchmark_filter=largerandom
-static void sax_parse_largerandom(State &state) {
-  // Load twitter.json to a buffer
-  const padded_string& json = get_my_json_str();
-
-  // Allocate
-  largerandom::sax_point_reader reader;
-  if (auto error = reader.set_capacity(json.size())) { throw error; }
-  // warming
-  for(size_t i = 0; i < 10; i++) {
-    if (auto error = reader.read_points(json)) { throw error; }
-  }
-
-  // Read
-  size_t bytes = 0;
-  for (SIMDJSON_UNUSED auto _ : state) {
-    if (auto error = reader.read_points(json)) { throw error; }
-    bytes += json.size();
-    benchmark::DoNotOptimize(reader.points.data());
-  }
-  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
-  state.counters["Gigabytes"] = benchmark::Counter(
-	        double(bytes), benchmark::Counter::kIsRate,
-	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
-  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
-}
-BENCHMARK(sax_parse_largerandom)->Repetitions(REPETITIONS)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
-    return *(std::max_element(std::begin(v), std::end(v)));
-  })->DisplayAggregatesOnly(true);
-
-#endif // SIMDJSON_IMPLEMENTATION_HASWELL
-
-#endif // SIMDJSON_EXCEPTIONS
+#include "partial_tweets/sax.h"
+#include "largerandom/sax.h"

 BENCHMARK_MAIN();
@@ -63,8 +63,8 @@ void print_usage(ostream& out) {
  out << "-s STAGE   - Stop after the given stage." << endl;
  out << "             -s stage1 - Stop after find_structural_bits." << endl;
  out << "             -s all    - Run all stages." << endl;
-  out << "-a ARCH    - Use the parser with the designated architecture (HASWELL, WESTMERE" << endl;
-  out << "             or ARM64). By default, detects best supported architecture." << endl;
+  out << "-a ARCH    - Use the parser with the designated architecture (HASWELL, WESTMERE," << endl;
+  out << "             PPC64 or ARM64). By default, detects best supported architecture." << endl;
 }

 void exit_usage(string message) {
@@ -96,8 +96,14 @@ struct option_struct {
      case 'v':
        verbose = true;
        break;
-      case 'a':
-        simdjson::active_implementation = simdjson::available_implementations[optarg];
+      case 'a': {
+          auto impl = simdjson::available_implementations[optarg];
+          if(impl && impl->supported_by_runtime_system()) {
+            simdjson::active_implementation = impl;
+          } else {
+            std::cerr << "implementation " << optarg << " not found or not supported " << std::endl;
+          }
+        }
        break;
      case 's':
        if (!strcmp(optarg, "stage1")) {
@@ -12,9 +12,9 @@
 #define BEST_TIME(name, test, expected, pre, repeat, size, verbose)            \
  do {                                                                         \
    if (verbose)                                                               \
-      printf("%-40s\t: ", name);                                               \
+      std::printf("%-40s\t: ", name);                                          \
    else                                                                       \
-      printf("\"%-40s\"", name);                                               \
+      std::printf("\"%-40s\"", name);                                          \
    fflush(NULL);                                                              \
    event_collector collector;                                                 \
    event_aggregate aggregate{};                                               \
@@ -23,7 +23,8 @@
      std::atomic_thread_fence(std::memory_order_acquire);                     \
      collector.start();                                                       \
      if (test != expected) {                                                  \
-        fprintf(stderr, "not expected (%d , %d )", (int)test, (int)expected);  \
+        std::fprintf(stderr, "not expected (%d , %d )", (int)test,             \
+                     (int)expected);                                           \
        break;                                                                 \
      }                                                                        \
      std::atomic_thread_fence(std::memory_order_release);                     \
@@ -31,39 +32,41 @@
      aggregate << allocate_count;                                             \
    }                                                                          \
    if (collector.has_events()) {                                              \
-      printf("%7.3f", aggregate.best.cycles() / static_cast<double>(size));    \
+      std::printf("%7.3f",                                                     \
+                  aggregate.best.cycles() / static_cast<double>(size));        \
      if (verbose) {                                                           \
-        printf(" cycles/byte ");                                               \
+        std::printf(" cycles/byte ");                                          \
      }                                                                        \
-      printf("\t");                                                            \
-      printf("%7.3f",                                                          \
-             aggregate.best.instructions() / static_cast<double>(size));       \
+      std::printf("\t");                                                       \
+      std::printf("%7.3f",                                                     \
+                  aggregate.best.instructions() / static_cast<double>(size));  \
      if (verbose) {                                                           \
-        printf(" instructions/byte ");                                         \
+        std::printf(" instructions/byte ");                                    \
      }                                                                        \
-      printf("\t");                                                            \
+      std::printf("\t");                                                       \
    }                                                                          \
    double gb = static_cast<double>(size) / 1000000000.0;                      \
-    printf("%7.3f", gb / aggregate.best.elapsed_sec());                        \
+    std::printf("%7.3f", gb / aggregate.best.elapsed_sec());                   \
    if (verbose) {                                                             \
-      printf(" GB/s ");                                                        \
+      std::printf(" GB/s ");                                                   \
    }                                                                          \
-    printf("%7.3f", 1.0 / aggregate.best.elapsed_sec());                       \
+    std::printf("\t"); \
+    std::printf("%7.3f", 1.0 / aggregate.best.elapsed_sec());                  \
    if (verbose) {                                                             \
-      printf(" documents/s ");                                                 \
+      std::printf(" documents/s ");                                            \
    }                                                                          \
-    printf("\n");                                                              \
-    fflush(NULL);                                                              \
+    std::printf("\n");                                                         \
+    std::fflush(NULL);                                                         \
  } while (0)

 // like BEST_TIME, but no check
 #define BEST_TIME_NOCHECK(name, test, pre, repeat, size, verbose)              \
  do {                                                                         \
    if (verbose)                                                               \
-      printf("%-40s\t: ", name);                                               \
+      std::printf("%-40s\t: ", name);                                          \
    else                                                                       \
-      printf("\"%-40s\"", name);                                               \
-    fflush(NULL);                                                              \
+      std::printf("\"%-40s\"", name);                                          \
+    std::fflush(NULL);                                                         \
    event_collector collector;                                                 \
    event_aggregate aggregate{};                                               \
    for (decltype(repeat) i = 0; i < repeat; i++) {                            \
@@ -76,29 +79,31 @@
      aggregate << allocate_count;                                             \
    }                                                                          \
    if (collector.has_events()) {                                              \
-      printf("%7.3f", aggregate.best.cycles() / static_cast<double>(size));    \
+      std::printf("%7.3f",                                                     \
+                  aggregate.best.cycles() / static_cast<double>(size));        \
      if (verbose) {                                                           \
-        printf(" cycles/byte ");                                               \
+        std::printf(" cycles/byte ");                                          \
      }                                                                        \
-      printf("\t");                                                            \
-      printf("%7.3f",                                                          \
-             aggregate.best.instructions() / static_cast<double>(size));       \
+      std::printf("\t");                                                       \
+      std::printf("%7.3f",                                                     \
+                  aggregate.best.instructions() / static_cast<double>(size));  \
      if (verbose) {                                                           \
-        printf(" instructions/byte ");                                         \
+        std::printf(" instructions/byte ");                                    \
      }                                                                        \
-      printf("\t");                                                            \
+      std::printf("\t");                                                       \
    }                                                                          \
    double gb = static_cast<double>(size) / 1000000000.0;                      \
-    printf("%7.3f", gb / aggregate.best.elapsed_sec());                        \
+    std::printf("%7.3f", gb / aggregate.best.elapsed_sec());                   \
    if (verbose) {                                                             \
-      printf(" GB/s ");                                                        \
+      std::printf(" GB/s ");                                                   \
    }                                                                          \
-    printf("%7.3f", 1.0 / aggregate.best.elapsed_sec());                       \
+    std::printf("\t");                                                       \
+    std::printf("%7.3f", 1.0 / aggregate.best.elapsed_sec());                  \
    if (verbose) {                                                             \
-      printf(" documents/s ");                                                 \
+      std::printf(" documents/s ");                                            \
    }                                                                          \
-    printf("\n");                                                              \
-    fflush(NULL);                                                              \
+    std::printf("\n");                                                         \
+    std::fflush(NULL);                                                         \
  } while (0)

 #endif
@@ -228,7 +228,7 @@ struct progress_bar {
 /**
 * The speed at which we can allocate memory is strictly system specific.
 * It depends on the OS and the runtime library. It is subject to various
- * system-specific knobs. It is not something that we can reasonably 
+ * system-specific knobs. It is not something that we can reasonably
 * benchmark with crude timings.
 * If someone wants to optimize how simdjson allocate memory, then it will
 * almost surely require a distinct benchmarking tool. What is meant by
@@ -7,7 +7,7 @@

 # Clone the repository if it's not there
 find_package(Git QUIET)
-if (SIMDJSON_IS_UNDER_GIT AND SIMDJSON_GIT AND Git_FOUND AND (GIT_VERSION_STRING VERSION_GREATER  "2.1.4") AND (NOT CMAKE_GENERATOR MATCHES Ninja) ) # We use "-C" which requires a recent git
+if (Git_FOUND AND (GIT_VERSION_STRING VERSION_GREATER  "2.1.4") AND (NOT CMAKE_GENERATOR MATCHES Ninja) ) # We use "-C" which requires a recent git
  message(STATUS "Git is available and it is recent. We are enabling checkperf targets.")
  # sync_git_repository(myrepo ...) creates two targets:
  # myrepo - if the repo does not exist, creates and syncs it against the origin branch
@@ -95,7 +95,7 @@ if (SIMDJSON_IS_UNDER_GIT AND SIMDJSON_GIT AND Git_FOUND AND (GIT_VERSION_STRING
 else()
  if (CMAKE_GENERATOR MATCHES Ninja)
   message(STATUS "We disable the checkperf targets under Ninja.")
-  else() 
+  else()
   message(STATUS "Either git is unavailable or else it is too old. We are disabling checkperf targets.")
  endif()
 endif ()
@@ -0,0 +1,52 @@
+
+#pragma once
+#include <vector>
+#include <cstdint>
+#include "event_counter.h"
+#include "json_benchmark.h"
+
+
+bool equals(const char *s1, const char *s2) { return strcmp(s1, s2) == 0; }
+
+void remove_duplicates(std::vector<int64_t> &v) {
+  std::sort(v.begin(), v.end());
+  auto last = std::unique(v.begin(), v.end());
+  v.erase(last, v.end());
+}
+
+//
+// Interface
+//
+
+namespace distinct_user_id {
+template<typename T> static void DistinctUserID(benchmark::State &state);
+} // namespace
+
+//
+// Implementation
+//
+
+#include "dom.h"
+
+
+namespace distinct_user_id {
+
+using namespace simdjson;
+
+template<typename T> static void DistinctUserID(benchmark::State &state) {
+  //
+  // Load the JSON file
+  //
+  constexpr const char *TWITTER_JSON = SIMDJSON_BENCHMARK_DATA_DIR "twitter.json";
+  error_code error;
+  padded_string json;
+  if ((error = padded_string::load(TWITTER_JSON).get(json))) {
+    std::cerr << error << std::endl;
+    state.SkipWithError("error loading");
+    return;
+  }
+
+  JsonBenchmark<T, Dom>(state, json);
+}
+
+} // namespace distinct_user_id
@@ -0,0 +1,89 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "distinctuserid.h"
+
+namespace distinct_user_id {
+
+using namespace simdjson;
+
+
+simdjson_really_inline void simdjson_recurse(std::vector<int64_t> & v, simdjson::dom::element element);
+void simdjson_recurse(std::vector<int64_t> & v, simdjson::dom::array array) {
+  for (auto child : array) {
+    simdjson_recurse(v, child);
+  }
+}
+void simdjson_recurse(std::vector<int64_t> & v, simdjson::dom::object object) {
+  for (auto [key, value] : object) {
+    if((key.size() == 4) && (memcmp(key.data(), "user", 4) == 0)) {
+      // we are in an object under the key "user"
+      simdjson::error_code error;
+      simdjson::dom::object child_object;
+      simdjson::dom::object child_array;
+      if (not (error = value.get(child_object))) {
+        for (auto [child_key, child_value] : child_object) {
+          if((child_key.size() == 2) && (memcmp(child_key.data(), "id", 2) == 0)) {
+            int64_t x;
+            if (not (error = child_value.get(x))) {
+              v.push_back(x);
+            }
+          }
+          simdjson_recurse(v, child_value);
+        }
+      } else if (not (error = value.get(child_array))) {
+        simdjson_recurse(v, child_array);
+      }
+      // end of: we are in an object under the key "user"
+    } else {
+      simdjson_recurse(v, value);
+    }
+  }
+}
+simdjson_really_inline void simdjson_recurse(std::vector<int64_t> & v, simdjson::dom::element element) {
+  simdjson_unused simdjson::error_code error;
+  simdjson::dom::array array;
+  simdjson::dom::object object;
+  if (not (error = element.get(array))) {
+    simdjson_recurse(v, array);
+  } else if (not (error = element.get(object))) {
+    simdjson_recurse(v, object);
+  }
+}
+
+
+
+
+
+class Dom {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+  simdjson_really_inline const std::vector<int64_t> &Result() { return ids; }
+  simdjson_really_inline size_t ItemCount() { return ids.size(); }
+
+private:
+  dom::parser parser{};
+  std::vector<int64_t> ids{};
+
+};
+void print_vec(const std::vector<int64_t> &v) {
+  for (auto i : v) {
+    std::cout << i << " ";
+  }
+  std::cout << std::endl;
+}
+
+simdjson_really_inline bool Dom::Run(const padded_string &json) {
+  ids.clear();
+  dom::element doc = parser.parse(json);
+  simdjson_recurse(ids, doc);
+  remove_duplicates(ids);
+  return true;
+}
+
+BENCHMARK_TEMPLATE(DistinctUserID, Dom);
+
+} // namespace distinct_user_id
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,67 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "distinctuserid.h"
+
+namespace distinct_user_id {
+
+using namespace simdjson;
+using namespace simdjson::builtin;
+
+
+class OnDemand {
+public:
+  OnDemand() {
+    if(!displayed_implementation) {
+      std::cout << "On Demand implementation: " << builtin_implementation()->name() << std::endl;
+      displayed_implementation = true;
+    }
+  }
+  simdjson_really_inline bool Run(const padded_string &json);
+  simdjson_really_inline const std::vector<int64_t> &Result() { return ids; }
+  simdjson_really_inline size_t ItemCount() { return ids.size(); }
+
+private:
+  ondemand::parser parser{};
+  std::vector<int64_t> ids{};
+
+  static inline bool displayed_implementation = false;
+};
+
+simdjson_really_inline bool OnDemand::Run(const padded_string &json) {
+  ids.clear();
+  // Walk the document, parsing as we go
+  auto doc = parser.iterate(json);
+  for (ondemand::object tweet : doc["statuses"]) {
+      // We believe that all statuses have a matching
+      // user, and we are willing to throw when they do not:
+      //
+      // You might think that you do not need the braces, but
+      // you do, otherwise you will get the wrong answer. That is
+      // because you can only have one active object or array
+      // at a time.
+      {
+        ondemand::object user = tweet["user"];
+        int64_t id = user["id"];
+        ids.push_back(id);
+      }
+      // Not all tweets have a "retweeted_status", but when they do
+      // we want to go and find the user within.
+      auto retweet = tweet["retweeted_status"];
+      if(!retweet.error()) {
+          ondemand::object retweet_content = retweet;
+          ondemand::object reuser = retweet_content["user"];
+          int64_t rid = reuser["id"];
+          ids.push_back(rid);
+      }
+  }
+  remove_duplicates(ids);
+  return true;
+}
+
+BENCHMARK_TEMPLATE(DistinctUserID, OnDemand);
+
+} // namespace distinct_user_id
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -38,7 +38,7 @@ void print_vec(const std::vector<int64_t> &v) {

 // clang-format off

-// simdjson_recurse below come be implemented like so but it is slow:
+// simdjson_recurse below can be implemented like so but it is slow:
 /*void simdjson_recurse(std::vector<int64_t> & v, simdjson::dom::element element) {
  error_code error;
  if (element.is_array()) {
@@ -98,7 +98,7 @@ void simdjson_recurse(std::vector<int64_t> & v, simdjson::dom::object object) {
  }
 }
 simdjson_really_inline void simdjson_recurse(std::vector<int64_t> & v, simdjson::dom::element element) {
-  SIMDJSON_UNUSED simdjson::error_code error;
+  simdjson_unused simdjson::error_code error;
  simdjson::dom::array array;
  simdjson::dom::object object;
  if (not (error = element.get(array))) {
@@ -116,18 +116,18 @@ struct event_collector {

 #if defined(__linux__)
  LinuxEvents<PERF_TYPE_HARDWARE> linux_events;
-  event_collector() : linux_events(vector<int>{
+  event_collector(bool quiet = false) : linux_events(vector<int>{
    PERF_COUNT_HW_CPU_CYCLES,
    PERF_COUNT_HW_INSTRUCTIONS,
    PERF_COUNT_HW_BRANCH_MISSES,
    PERF_COUNT_HW_CACHE_REFERENCES,
    PERF_COUNT_HW_CACHE_MISSES
-  }) {}
+  }, quiet) {}
  bool has_events() {
    return linux_events.is_working();
  }
 #else
-  event_collector() {}
+  event_collector(simdjson_unused bool _quiet = false) {}
  bool has_events() {
    return false;
  }
@@ -29,7 +29,7 @@ int main(int argc, char *argv[]) {
              << std::endl;
  }
  simdjson::padded_string p;
-  bench(filename, p); 
+  bench(filename, p);
  double meanval = 0;
  double maxval = 0;
  double minval = 10000;
@@ -0,0 +1,80 @@
+#pragma once
+
+template<typename B, typename R> static void JsonBenchmark(benchmark::State &state, const simdjson::padded_string &json) {
+  event_collector collector(true);
+  event_aggregate events;
+
+  // Warmup and equality check (make sure the data is right!)
+  B bench;
+  if (!bench.Run(json)) { state.SkipWithError("warmup tweet reading failed"); return; }
+  {
+    R reference;
+    if (!reference.Run(json)) { state.SkipWithError("reference tweet reading failed"); return; }
+    if (bench.Result() != reference.Result()) { state.SkipWithError("results are not the same"); return; }
+  }
+
+  // Run the benchmark
+  for (simdjson_unused auto _ : state) {
+    collector.start();
+
+    if (!bench.Run(json)) { state.SkipWithError("tweet reading failed"); return; }
+
+    events << collector.end();
+  }
+
+  state.SetBytesProcessed(json.size() * state.iterations());
+  state.SetItemsProcessed(bench.ItemCount() * state.iterations());
+  state.counters["best_bytes_per_sec"] = benchmark::Counter(double(json.size()) / events.best.elapsed_sec());
+  state.counters["best_items_per_sec"] = benchmark::Counter(double(bench.ItemCount()) / events.best.elapsed_sec());
+
+  state.counters["docs_per_sec"] = benchmark::Counter(1.0, benchmark::Counter::kIsIterationInvariantRate);
+  state.counters["best_docs_per_sec"] = benchmark::Counter(1.0 / events.best.elapsed_sec());
+
+  if (collector.has_events()) {
+    state.counters["instructions"] = events.instructions();
+    state.counters["cycles"]       = events.cycles();
+    state.counters["branch_miss"]  = events.branch_misses();
+    state.counters["cache_miss"]   = events.cache_misses();
+    state.counters["cache_ref"]    = events.cache_references();
+
+    state.counters["instructions_per_byte"]  = events.instructions() / double(json.size());
+    state.counters["instructions_per_cycle"] = events.instructions() / events.cycles();
+    state.counters["cycles_per_byte"]        = events.cycles()       / double(json.size());
+    state.counters["frequency"]              = benchmark::Counter(events.cycles(), benchmark::Counter::kIsIterationInvariantRate);
+
+    state.counters["best_instructions"] = events.best.instructions();
+    state.counters["best_cycles"]       = events.best.cycles();
+    state.counters["best_branch_miss"]  = events.best.branch_misses();
+    state.counters["best_cache_miss"]   = events.best.cache_misses();
+    state.counters["best_cache_ref"]    = events.best.cache_references();
+
+    state.counters["best_instructions_per_byte"]  = events.best.instructions() / double(json.size());
+    state.counters["best_instructions_per_cycle"] = events.best.instructions() / events.best.cycles();
+    state.counters["best_cycles_per_byte"]        = events.best.cycles()       / double(json.size());
+    state.counters["best_frequency"]              = events.best.cycles()       / events.best.elapsed_sec();
+  }
+  state.counters["bytes"] = benchmark::Counter(double(json.size()));
+  state.counters["items"] = benchmark::Counter(double(bench.ItemCount()));
+
+  // Build the label
+  using namespace std;
+  stringstream label;
+  label << fixed << setprecision(2);
+  label << "[best:";
+  label << " throughput="     << setw(6)  << (double(json.size()) / 1000000000.0     / events.best.elapsed_sec()) << " GB/s";
+  label << " doc_throughput=" << setw(6)  << uint64_t(1.0                            / events.best.elapsed_sec()) << " docs/s";
+
+  if (collector.has_events()) {
+    label << " instructions=" << setw(12) << uint64_t(events.best.instructions())     << setw(0);
+    label << " cycles="       << setw(12) << uint64_t(events.best.cycles())           << setw(0);
+    label << " branch_miss="  << setw(8)  << uint64_t(events.best.branch_misses())    << setw(0);
+    label << " cache_miss="   << setw(8)  << uint64_t(events.best.cache_misses())     << setw(0);
+    label << " cache_ref="    << setw(10) << uint64_t(events.best.cache_references()) << setw(0);
+  }
+
+  label << " items=" << setw(10) << bench.ItemCount() << setw(0);
+  label << " avg_time=" << setw(10) << uint64_t(events.elapsed_ns()) << setw(0) << " ns";
+  label << "]";
+
+  state.SetLabel(label.str());
+}
@@ -0,0 +1,69 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "kostya.h"
+
+namespace kostya {
+
+using namespace simdjson;
+
+class Dom {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+
+  simdjson_really_inline const std::vector<my_point> &Result() { return container; }
+  simdjson_really_inline size_t ItemCount() { return container.size(); }
+
+private:
+  dom::parser parser{};
+  std::vector<my_point> container{};
+};
+
+simdjson_really_inline bool Dom::Run(const padded_string &json) {
+  container.clear();
+
+  for (auto point : parser.parse(json)["coordinates"]) {
+    container.emplace_back(my_point{point["x"], point["y"], point["z"]});
+  }
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(Kostya, Dom);
+
+namespace sum {
+
+class Dom {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+
+  simdjson_really_inline my_point &Result() { return sum; }
+  simdjson_really_inline size_t ItemCount() { return count; }
+
+private:
+  dom::parser parser{};
+  my_point sum{};
+  size_t count{};
+};
+
+simdjson_really_inline bool Dom::Run(const padded_string &json) {
+  sum = { 0, 0, 0 };
+  count = 0;
+
+  for (auto coord : parser.parse(json)["coordinates"]) {
+    sum.x += double(coord["x"]);
+    sum.y += double(coord["y"]);
+    sum.z += double(coord["z"]);
+    count++;
+  }
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(KostyaSum, Dom);
+
+} // namespace sum
+} // namespace kostya
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,96 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "kostya.h"
+
+namespace kostya {
+
+using namespace simdjson;
+using namespace simdjson::builtin;
+
+class Iter {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+
+  simdjson_really_inline const std::vector<my_point> &Result() { return container; }
+  simdjson_really_inline size_t ItemCount() { return container.size(); }
+
+private:
+  ondemand::parser parser{};
+  std::vector<my_point> container{};
+
+  simdjson_really_inline simdjson_result<double> first_double(ondemand::json_iterator &iter, const char *key) {
+    if (!iter.start_object() || ondemand::raw_json_string(iter.field_key()) != key || iter.field_value()) { throw "Invalid field"; }
+    return iter.consume_double();
+  }
+
+  simdjson_really_inline simdjson_result<double> next_double(ondemand::json_iterator &iter, const char *key) {
+    if (!iter.has_next_field() || ondemand::raw_json_string(iter.field_key()) != key || iter.field_value()) { throw "Invalid field"; }
+    return iter.consume_double();
+  }
+
+};
+
+simdjson_really_inline bool Iter::Run(const padded_string &json) {
+  container.clear();
+
+  using std::cerr;
+  using std::endl;
+  auto iter = parser.iterate_raw(json).value();
+  if (!iter.start_object() || !iter.find_field_raw("coordinates")) { cerr << "find coordinates field failed" << endl; return false; }
+  if (iter.start_array()) {
+    do {
+      container.emplace_back(my_point{first_double(iter, "x"), next_double(iter, "y"), next_double(iter, "z")});
+      if (iter.skip_container()) { return false; } // Skip the rest of the coordinates object
+    } while (iter.has_next_element());
+  }
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(Kostya, Iter);
+
+
+namespace sum {
+
+class Iter {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+
+  simdjson_really_inline my_point &Result() { return sum; }
+  simdjson_really_inline size_t ItemCount() { return count; }
+
+private:
+  ondemand::parser parser{};
+  my_point sum{};
+  size_t count{};
+};
+
+simdjson_really_inline bool Iter::Run(const padded_string &json) {
+  sum = {0,0,0};
+  count = 0;
+
+  auto iter = parser.iterate_raw(json).value();
+  if (!iter.start_object() || !iter.find_field_raw("coordinates")) { return false; }
+  if (!iter.start_array()) { return false; }
+  do {
+    if (!iter.start_object()   || !iter.find_field_raw("x")) { return false; }
+    sum.x += iter.consume_double();
+    if (!iter.has_next_field() || !iter.find_field_raw("y")) { return false; }
+    sum.y +=  iter.consume_double();
+    if (!iter.has_next_field() || !iter.find_field_raw("z")) { return false; }
+    sum.z +=  iter.consume_double();
+    if (iter.skip_container()) { return false; } // Skip the rest of the coordinates object
+    count++;
+  } while (iter.has_next_element());
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(KostyaSum, Iter);
+
+} // namespace sum
+} // namespace kostya
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,95 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+//
+// Interface
+//
+
+namespace kostya {
+template<typename T> static void Kostya(benchmark::State &state);
+namespace sum {
+template<typename T> static void KostyaSum(benchmark::State &state);
+}
+
+using namespace simdjson;
+
+static void append_coordinate(std::default_random_engine &e, std::uniform_real_distribution<> &dis, std::stringstream &myss) {
+  using std::endl;
+  myss << R"(        {)" << endl;
+  myss << R"(            "x": )" << dis(e) << "," << endl;
+  myss << R"(            "y": )" << dis(e) << "," << endl;
+  myss << R"(            "z": )" << dis(e) << "," << endl;
+  myss << R"(            "name": ")" << char('a'+dis(e)*25) << char('a'+dis(e)*25) << char('a'+dis(e)*25) << char('a'+dis(e)*25) << char('a'+dis(e)*25) << char('a'+dis(e)*25) << " " << int(dis(e)*10000) << "\"," << endl;
+  myss << R"(            "opts": {)" << endl;
+  myss << R"(                "1": [)" << endl;
+  myss << R"(                    1,)" << endl;
+  myss << R"(                    true)" << endl;
+  myss << R"(                ])" << endl;
+  myss << R"(            })" << endl;
+  myss << R"(        })";
+}
+
+static std::string build_json_array(size_t N) {
+  using namespace std;
+  default_random_engine e;
+  uniform_real_distribution<> dis(0, 1);
+  stringstream myss;
+  myss << R"({)" << endl;
+  myss << R"(    "coordinates": [)" << endl;
+  for (size_t i=1; i<N; i++) {
+    append_coordinate(e, dis, myss); myss << "," << endl;
+  }
+  append_coordinate(e, dis, myss); myss << endl;
+  myss << R"(    ],)" << endl;
+  myss << R"(    "info": "some info")" << endl;
+  myss << R"(})" << endl;
+  string answer = myss.str();
+  cout << "Creating a source file spanning " << (answer.size() + 512) / 1024 << " KB " << endl;
+  return answer;
+}
+
+static const padded_string &get_built_json_array() {
+  static padded_string json = build_json_array(524288);
+  return json;
+}
+
+struct my_point {
+  double x;
+  double y;
+  double z;
+  simdjson_really_inline bool operator==(const my_point &other) const {
+    return x == other.x && y == other.y && z == other.z;
+  }
+  simdjson_really_inline bool operator!=(const my_point &other) const { return !(*this == other); }
+};
+
+simdjson_unused static std::ostream &operator<<(std::ostream &o, const my_point &p) {
+  return o << p.x << "," << p.y << "," << p.z << std::endl;
+}
+
+} // namespace kostya
+
+//
+// Implementation
+//
+#include <vector>
+#include "event_counter.h"
+#include "dom.h"
+#include "json_benchmark.h"
+
+namespace kostya {
+
+template<typename T> static void Kostya(benchmark::State &state) {
+  JsonBenchmark<T, Dom>(state, get_built_json_array());
+}
+
+namespace sum {
+template<typename T> static void KostyaSum(benchmark::State &state) {
+  JsonBenchmark<T, Dom>(state, get_built_json_array());
+}
+}
+
+} // namespace kostya
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,74 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "kostya.h"
+
+namespace kostya {
+
+using namespace simdjson;
+using namespace simdjson::builtin;
+
+class OnDemand {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+  simdjson_really_inline const std::vector<my_point> &Result() { return container; }
+  simdjson_really_inline size_t ItemCount() { return container.size(); }
+
+private:
+  ondemand::parser parser{};
+  std::vector<my_point> container{};
+};
+
+simdjson_really_inline bool OnDemand::Run(const padded_string &json) {
+  container.clear();
+
+  using std::cout;
+  using std::endl;
+
+  auto doc = parser.iterate(json);
+  for (ondemand::object coord : doc["coordinates"]) {
+    container.emplace_back(my_point{coord["x"], coord["y"], coord["z"]});
+  }
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(Kostya, OnDemand);
+
+
+namespace sum {
+
+class OnDemand {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+  simdjson_really_inline my_point &Result() { return sum; }
+  simdjson_really_inline size_t ItemCount() { return count; }
+
+private:
+  ondemand::parser parser{};
+  my_point sum{};
+  size_t count{};
+};
+
+simdjson_really_inline bool OnDemand::Run(const padded_string &json) {
+  sum = {0,0,0};
+  count = 0;
+
+  auto doc = parser.iterate(json);
+  for (ondemand::object coord : doc["coordinates"]) {
+    sum.x += double(coord["x"]);
+    sum.y += double(coord["y"]);
+    sum.z += double(coord["z"]);
+    count++;
+  }
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(KostyaSum, OnDemand);
+
+} // namespace sum
+} // namespace kostya
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,69 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "largerandom.h"
+
+namespace largerandom {
+
+using namespace simdjson;
+
+class Dom {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+
+  simdjson_really_inline const std::vector<my_point> &Result() { return container; }
+  simdjson_really_inline size_t ItemCount() { return container.size(); }
+
+private:
+  dom::parser parser{};
+  std::vector<my_point> container{};
+};
+
+simdjson_really_inline bool Dom::Run(const padded_string &json) {
+  container.clear();
+
+  for (auto point : parser.parse(json)) {
+    container.emplace_back(my_point{point["x"], point["y"], point["z"]});
+  }
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(LargeRandom, Dom);
+
+namespace sum {
+
+class Dom {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+
+  simdjson_really_inline my_point &Result() { return sum; }
+  simdjson_really_inline size_t ItemCount() { return count; }
+
+private:
+  dom::parser parser{};
+  my_point sum{};
+  size_t count{};
+};
+
+simdjson_really_inline bool Dom::Run(const padded_string &json) {
+  sum = { 0, 0, 0 };
+  count = 0;
+
+  for (auto coord : parser.parse(json)) {
+    sum.x += double(coord["x"]);
+    sum.y += double(coord["y"]);
+    sum.z += double(coord["z"]);
+    count++;
+  }
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(LargeRandomSum, Dom);
+
+} // namespace sum
+} // namespace largerandom
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,92 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "largerandom.h"
+
+namespace largerandom {
+
+using namespace simdjson;
+using namespace simdjson::builtin;
+
+class Iter {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+
+  simdjson_really_inline const std::vector<my_point> &Result() { return container; }
+  simdjson_really_inline size_t ItemCount() { return container.size(); }
+
+private:
+  ondemand::parser parser{};
+  std::vector<my_point> container{};
+
+  simdjson_really_inline double first_double(ondemand::json_iterator &iter) {
+    if (iter.start_object().error() || iter.field_key().error() || iter.field_value()) { throw "Invalid field"; }
+    return iter.consume_double();
+  }
+
+  simdjson_really_inline double next_double(ondemand::json_iterator &iter) {
+    if (!iter.has_next_field() || iter.field_key().error() || iter.field_value()) { throw "Invalid field"; }
+    return iter.consume_double();
+  }
+
+};
+
+simdjson_really_inline bool Iter::Run(const padded_string &json) {
+  container.clear();
+
+  auto iter = parser.iterate_raw(json).value();
+  if (iter.start_array()) {
+    do {
+      container.emplace_back(my_point{first_double(iter), next_double(iter), next_double(iter)});
+      if (iter.has_next_field()) { throw "Too many fields"; }
+    } while (iter.has_next_element());
+  }
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(LargeRandom, Iter);
+
+
+namespace sum {
+
+class Iter {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+
+  simdjson_really_inline my_point &Result() { return sum; }
+  simdjson_really_inline size_t ItemCount() { return count; }
+
+private:
+  ondemand::parser parser{};
+  my_point sum{};
+  size_t count{};
+};
+
+simdjson_really_inline bool Iter::Run(const padded_string &json) {
+  sum = {0,0,0};
+  count = 0;
+
+  auto iter = parser.iterate_raw(json).value();
+  if (!iter.start_array()) { return false; }
+  do {
+    if (!iter.start_object()   || iter.field_key().value() != "x" || iter.field_value()) { return false; }
+    sum.x += iter.consume_double();
+    if (!iter.has_next_field() || iter.field_key().value() != "y" || iter.field_value()) { return false; }
+    sum.y +=  iter.consume_double();
+    if (!iter.has_next_field() || iter.field_key().value() != "z" || iter.field_value()) { return false; }
+    sum.z +=  iter.consume_double();
+    if (*iter.advance() != '}') { return false; }
+    count++;
+  } while (iter.has_next_element());
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(LargeRandomSum, Iter);
+
+} // namespace sum
+} // namespace largerandom
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,80 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+//
+// Interface
+//
+
+namespace largerandom {
+template<typename T> static void LargeRandom(benchmark::State &state);
+namespace sum {
+template<typename T> static void LargeRandomSum(benchmark::State &state);
+}
+
+using namespace simdjson;
+
+static std::string build_json_array(size_t N) {
+  std::default_random_engine e;
+  std::uniform_real_distribution<> dis(0, 1);
+  std::stringstream myss;
+  myss << "[" << std::endl;
+  if(N > 0) {
+    myss << "{ \"x\":" << dis(e) << ",  \"y\":" << dis(e) << ", \"z\":" << dis(e) << "}" << std::endl;
+  }
+  for(size_t i = 1; i < N; i++) {
+    myss << "," << std::endl;
+    myss << "{ \"x\":" << dis(e) << ",  \"y\":" << dis(e) << ", \"z\":" << dis(e) << "}";
+  }
+  myss << std::endl;
+  myss << "]" << std::endl;
+  std::string answer = myss.str();
+  std::cout << "Creating a source file spanning " << (answer.size() + 512) / 1024 << " KB " << std::endl;
+  return answer;
+}
+
+static const padded_string &get_built_json_array() {
+  static padded_string json = build_json_array(1000000);
+  return json;
+}
+
+struct my_point {
+  double x;
+  double y;
+  double z;
+  simdjson_really_inline bool operator==(const my_point &other) const {
+    return x == other.x && y == other.y && z == other.z;
+  }
+  simdjson_really_inline bool operator!=(const my_point &other) const { return !(*this == other); }
+};
+
+simdjson_unused static std::ostream &operator<<(std::ostream &o, const my_point &p) {
+  return o << p.x << "," << p.y << "," << p.z << std::endl;
+}
+
+} // namespace largerandom
+
+//
+// Implementation
+//
+#include <vector>
+#include "event_counter.h"
+#include "dom.h"
+#include "json_benchmark.h"
+
+namespace largerandom {
+
+template<typename T> static void LargeRandom(benchmark::State &state) {
+  JsonBenchmark<T, Dom>(state, get_built_json_array());
+}
+
+namespace sum {
+
+template<typename T> static void LargeRandomSum(benchmark::State &state) {
+  JsonBenchmark<T, Dom>(state, get_built_json_array());
+}
+
+}
+} // namespace largerandom
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,71 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "largerandom.h"
+
+namespace largerandom {
+
+using namespace simdjson;
+using namespace simdjson::builtin;
+
+class OnDemand {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+  simdjson_really_inline const std::vector<my_point> &Result() { return container; }
+  simdjson_really_inline size_t ItemCount() { return container.size(); }
+
+private:
+  ondemand::parser parser{};
+  std::vector<my_point> container{};
+};
+
+simdjson_really_inline bool OnDemand::Run(const padded_string &json) {
+  container.clear();
+
+  auto doc = parser.iterate(json);
+  for (ondemand::object coord : doc) {
+    container.emplace_back(my_point{coord["x"], coord["y"], coord["z"]});
+  }
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(LargeRandom, OnDemand);
+
+
+namespace sum {
+
+class OnDemand {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+  simdjson_really_inline my_point &Result() { return sum; }
+  simdjson_really_inline size_t ItemCount() { return count; }
+
+private:
+  ondemand::parser parser{};
+  my_point sum{};
+  size_t count{};
+};
+
+simdjson_really_inline bool OnDemand::Run(const padded_string &json) {
+  sum = {0,0,0};
+  count = 0;
+
+  auto doc = parser.iterate(json);
+  for (ondemand::object coord : doc.get_array()) {
+    sum.x += double(coord["x"]);
+    sum.y += double(coord["y"]);
+    sum.z += double(coord["z"]);
+    count++;
+  }
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(LargeRandomSum, OnDemand);
+
+} // namespace sum
+} // namespace largerandom
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,121 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "largerandom.h"
+
+namespace largerandom {
+
+using namespace simdjson;
+using namespace simdjson::builtin;
+using namespace simdjson::builtin::stage2;
+
+class Sax {
+public:
+  simdjson_really_inline bool Run(const padded_string &json) noexcept;
+
+  simdjson_really_inline const std::vector<my_point> &Result() { return container; }
+  simdjson_really_inline size_t ItemCount() { return container.size(); }
+
+private:
+  simdjson_really_inline error_code RunNoExcept(const padded_string &json) noexcept;
+  error_code Allocate(size_t new_capacity);
+  std::unique_ptr<uint8_t[]> string_buf{};
+  size_t capacity{};
+  dom_parser_implementation dom_parser{};
+  std::vector<my_point> container{};
+};
+
+struct sax_point_reader_visitor {
+public:
+  std::vector<my_point> &points;
+  enum {GOT_X=0, GOT_Y=1, GOT_Z=2, GOT_SOMETHING_ELSE=4};
+  size_t idx{GOT_SOMETHING_ELSE};
+  double buffer[3]={};
+
+  explicit sax_point_reader_visitor(std::vector<my_point> &_points) : points(_points) {}
+
+  simdjson_really_inline error_code visit_object_start(json_iterator &) {
+    idx = 0;
+    return SUCCESS;
+  }
+  simdjson_really_inline error_code visit_primitive(json_iterator &, const uint8_t *value) {
+    if(idx == GOT_SOMETHING_ELSE) { return simdjson::SUCCESS; }
+    return numberparsing::parse_double(value).get(buffer[idx]);
+  }
+  simdjson_really_inline error_code visit_object_end(json_iterator &)  {
+    points.emplace_back(my_point{buffer[0], buffer[1], buffer[2]});
+    return SUCCESS;
+  }
+
+  simdjson_really_inline error_code visit_document_start(json_iterator &) { return SUCCESS; }
+  simdjson_really_inline error_code visit_key(json_iterator &, const uint8_t * key) {
+    switch(key[1]) {
+      // Technically, we should check the other characters
+      // in the key, but we are cheating to go as fast
+      // as possible.
+      case 'x':
+        idx = GOT_X;
+        break;
+      case 'y':
+        idx = GOT_Y;
+        break;
+      case 'z':
+        idx = GOT_Z;
+        break;
+      default:
+        idx = GOT_SOMETHING_ELSE;
+    }
+    return SUCCESS;
+  }
+  simdjson_really_inline error_code visit_array_start(json_iterator &)  { return SUCCESS; }
+  simdjson_really_inline error_code visit_array_end(json_iterator &) { return SUCCESS; }
+  simdjson_really_inline error_code visit_document_end(json_iterator &)  { return SUCCESS; }
+  simdjson_really_inline error_code visit_empty_array(json_iterator &)  { return SUCCESS; }
+  simdjson_really_inline error_code visit_empty_object(json_iterator &)  { return SUCCESS; }
+  simdjson_really_inline error_code visit_root_primitive(json_iterator &, const uint8_t *)  { return SUCCESS; }
+  simdjson_really_inline error_code increment_count(json_iterator &) { return SUCCESS; }
+};
+
+// NOTE: this assumes the dom_parser is already allocated
+bool Sax::Run(const padded_string &json) noexcept {
+  auto error = RunNoExcept(json);
+  if (error) { std::cerr << error << std::endl; return false; }
+  return true;
+}
+
+error_code Sax::RunNoExcept(const padded_string &json) noexcept {
+  container.clear();
+
+  // Allocate capacity if needed
+  if (capacity < json.size()) {
+    SIMDJSON_TRY( Allocate(json.size()) );
+  }
+
+  // Run stage 1 first.
+  SIMDJSON_TRY( dom_parser.stage1(json.u8data(), json.size(), false) );
+
+  // Then walk the document, parsing the tweets as we go
+  json_iterator iter(dom_parser, 0);
+  sax_point_reader_visitor visitor(container);
+  SIMDJSON_TRY( iter.walk_document<false>(visitor) );
+  return SUCCESS;
+}
+
+error_code Sax::Allocate(size_t new_capacity) {
+  // string_capacity copied from document::allocate
+  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + SIMDJSON_PADDING, 64);
+  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
+  if (auto error = dom_parser.set_capacity(new_capacity)) { return error; }
+  if (capacity == 0) { // set max depth the first time only
+    if (auto error = dom_parser.set_max_depth(DEFAULT_MAX_DEPTH)) { return error; }
+  }
+  capacity = new_capacity;
+  return SUCCESS;
+}
+
+BENCHMARK_TEMPLATE(LargeRandom, Sax);
+
+} // namespace largerandom
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -1,14 +1,22 @@
 // https://github.com/WojciechMula/toys/blob/master/000helpers/linux-perf-events.h
 #pragma once
 #ifdef __linux__
-
+#ifdef __has_include
+#if __has_include(<asm/unistd.h>)
 #include <asm/unistd.h>       // for __NR_perf_event_open
+#else
+#warning "Header asm/unistd.h cannot be found though it is a linux system. Are linux headers missing?"
+#endif
+#else // no __has_include
+// Please insure that linux headers have been installed.
+#include <asm/unistd.h>       // for __NR_perf_event_open
+#endif
 #include <linux/perf_event.h> // for perf event constants
 #include <sys/ioctl.h>        // for ioctl
 #include <unistd.h>           // for syscall

 #include <cerrno>  // for errno
-#include <cstring> // for memset
+#include <cstring> // for std::memset
 #include <stdexcept>

 #include <iostream>
@@ -21,10 +29,11 @@ template <int TYPE = PERF_TYPE_HARDWARE> class LinuxEvents {
  size_t num_events{};
  std::vector<uint64_t> temp_result_vec{};
  std::vector<uint64_t> ids{};
+  bool quiet;

 public:
-  explicit LinuxEvents(std::vector<int> config_vec) : fd(0), working(true) {
-    memset(&attribs, 0, sizeof(attribs));
+  explicit LinuxEvents(std::vector<int> config_vec, bool _quiet=false) : fd(0), working(true), quiet{_quiet} {
+    std::memset(&attribs, 0, sizeof(attribs));
    attribs.type = TYPE;
    attribs.size = sizeof(attribs);
    attribs.disabled = 1;
@@ -93,8 +102,11 @@ public:

 private:
  void report_error(const std::string &context) {
-    if (working)
-      std::cerr << (context + ": " + std::string(strerror(errno))) << std::endl;
+    if (!quiet) {
+      if (working) {
+        std::cerr << (context + ": " + std::string(strerror(errno))) << std::endl;
+      }
+    }
    working = false;
  }
 };
@@ -48,7 +48,9 @@ std::string rapid_stringme(char *json) {
 std::string simdjson_stringme(simdjson::padded_string & json) {
  std::stringstream ss;
  dom::parser parser;
-  dom::element doc = parser.parse(json);
+  dom::element doc;
+  auto error = parser.parse(json).get(doc);
+  if (error) { std::cerr << error << std::endl; abort(); }
  ss << simdjson::minify(doc);
  return ss.str();
 }
@@ -120,14 +122,16 @@ int main(int argc, char *argv[]) {
  BEST_TIME_NOCHECK(
      "despacing with std::minify", simdjson_stringme(p),, repeat, volume, !just_data);

-      
+
  memcpy(buffer, p.data(), p.size());
  size_t outlength;
  uint8_t *cbuffer = (uint8_t *)buffer;
  for (auto imple : simdjson::available_implementations) {
-    BEST_TIME((std::string("simdjson->minify+")+imple->name()).c_str(), (imple->minify(cbuffer, p.size(), cbuffer, outlength) == simdjson::SUCCESS ? outlength : -1),
+    if(imple->supported_by_runtime_system()) {
+      BEST_TIME((std::string("simdjson->minify+")+imple->name()).c_str(), (imple->minify(cbuffer, p.size(), cbuffer, outlength) == simdjson::SUCCESS ? outlength : -1),
            outlength, memcpy(buffer, p.data(), p.size()), repeat, volume,
            !just_data);
+    }
  }

  printf("minisize = %zu, original size = %zu  (minified down to %.2f percent "
@@ -67,7 +67,9 @@ void print_usage(ostream& out) {
  out << "-a IMPL      - Use the given parser implementation. By default, detects the most advanced" << endl;
  out << "               implementation supported on the host machine." << endl;
  for (auto impl : simdjson::available_implementations) {
-    out << "-a " << std::left << std::setw(9) << impl->name() << " - Use the " << impl->description() << " parser implementation." << endl;
+    if(impl->supported_by_runtime_system()) {
+      out << "-a " << std::left << std::setw(9) << impl->name() << " - Use the " << impl->description() << " parser implementation." << endl;
+    }
  }
 }

@@ -115,11 +117,13 @@ struct option_struct {
        break;
      case 'a': {
        const implementation *impl = simdjson::available_implementations[optarg];
-        if (!impl) {
+        if ((!impl) || (!impl->supported_by_runtime_system())) {
          std::string exit_message = string("Unsupported option value -a ") + optarg + ": expected -a  with one of ";
          for (auto imple : simdjson::available_implementations) {
-            exit_message += imple->name();
-            exit_message += " ";
+            if(imple->supported_by_runtime_system()) {
+              exit_message += imple->name();
+              exit_message += " ";
+            }
          }
          exit_usage(exit_message);
        }
@@ -131,24 +131,34 @@ struct Stat {
  size_t stringLength; // Number of code units in all strings
 };

-static void GenStatPlus(Stat &stat, const dom::element v) {
+static error_code GenStatPlus(Stat &stat, const dom::element &v);
+static error_code GenStatPlus(Stat &stat, const simdjson_result<dom::element> &r) {
+  dom::element v;
+  SIMDJSON_TRY( r.get(v) );
+  return GenStatPlus(stat, v);
+}
+static error_code GenStatPlus(Stat &stat, const dom::element &v) {
  switch (v.type()) {
-  case dom::element_type::ARRAY:
-    for (dom::element child : dom::array(v)) {
+  case dom::element_type::ARRAY: {
+    dom::array a;
+    SIMDJSON_TRY( v.get(a) )
+    for (auto child : a) {
      GenStatPlus(stat, child);
      stat.elementCount++;
    }
    stat.arrayCount++;
-    break;
-  case dom::element_type::OBJECT:
-    for (dom::key_value_pair kv : dom::object(v)) {
+  } break;
+  case dom::element_type::OBJECT: {
+    dom::object o;
+    SIMDJSON_TRY( v.get(o) );
+    for (dom::key_value_pair kv : o) {
      GenStatPlus(stat, kv.value);
      stat.stringLength += kv.key.size();
      stat.memberCount++;
      stat.stringCount++;
    }
    stat.objectCount++;
-    break;
+  } break;
  case dom::element_type::INT64:
  case dom::element_type::UINT64:
  case dom::element_type::DOUBLE:
@@ -156,20 +166,24 @@ static void GenStatPlus(Stat &stat, const dom::element v) {
    break;
  case dom::element_type::STRING: {
    stat.stringCount++;
-    auto sv = std::string_view(v);
+    std::string_view sv;
+    SIMDJSON_TRY( v.get(sv) );
    stat.stringLength += sv.size();
  } break;
-  case dom::element_type::BOOL:
-    if (bool(v)) {
+  case dom::element_type::BOOL: {
+    bool b;
+    SIMDJSON_TRY( v.get(b) );
+    if (b) {
      stat.trueCount++;
    } else {
      stat.falseCount++;
    }
-    break;
+  } break;
  case dom::element_type::NULL_VALUE:
    ++stat.nullCount;
    break;
  }
+  return SUCCESS;
 }

 static void RapidGenStat(Stat &stat, const rapidjson::Value &v) {
@@ -221,7 +235,8 @@ simdjson_never_inline Stat rapidjson_compute_stats_ref(const rapidjson::Value &d
 simdjson_never_inline Stat
 simdjson_compute_stats_refplus(const simdjson::dom::element &doc) {
  Stat s{};
-  GenStatPlus(s, doc);
+  auto error = GenStatPlus(s, doc);
+  if (error) { std::cerr << error << std::endl; abort(); }
  return s;
 }

@@ -469,9 +484,7 @@ int main(int argc, char *argv[]) {
    simdjson::dom::parser parser;
    simdjson::dom::element doc;
    auto error = parser.parse(p).get(doc);
-    if (error) {
-      std::cerr << error << std::endl;
-    }
+    if (error) { std::cerr << error << std::endl; abort(); }
    size_t refval = simdjson_compute_stats_refplus(doc).objectCount;

    BEST_TIME("simdjson            ",
@@ -13,6 +13,7 @@
 #include "benchmark.h"

 SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
+#include "yyjson.h"

 // #define RAPIDJSON_SSE2 // bad for performance
 // #define RAPIDJSON_SSE42 // bad for performance
@@ -26,23 +27,30 @@ SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;

+#ifdef HAS_BOOST_JSON
+#include <boost/json/parser.hpp>
+#include <boost/json/monotonic_resource.hpp>
+#endif
+
 #ifdef ALLPARSER

-#include "fastjson.cpp"
-#include "fastjson_dom.cpp"
-#include "gason.cpp"
+#include "fastjson/core.h"
+#include "fastjson/dom.h"
+#include "fastjson/fastjson.h"
+
+#include "gason.h"
+
+#include "json11.hpp"

-#include "json11.cpp"
-extern "C" {
-#include "cJSON.c"
 #include "cJSON.h"
-#include "jsmn.c"
+
 #include "jsmn.h"
+
 #include "ujdecode.h"
-#include "ultrajsondec.c"
+extern "C" {
+#include "ultrajson.h"
 }

-#include "jsoncpp.cpp"
 #include "json/json.h"

 #endif
@@ -53,7 +61,7 @@ using namespace rapidjson;

 #ifdef ALLPARSER
 // fastjson has a tricky interface
-void on_json_error(void *, SIMDJSON_UNUSED const fastjson::ErrorContext &ec) {
+void on_json_error(void *, simdjson_unused const fastjson::ErrorContext &ec) {
  // std::cerr<<"ERROR: "<<ec.mesg<<std::endl;
 }
 bool fastjson_parse(const char *input) {
@@ -65,32 +73,35 @@ bool fastjson_parse(const char *input) {
 // end of fastjson stuff
 #endif

-simdjson_never_inline size_t sum_line_lengths(std::stringstream & is) {
+simdjson_never_inline size_t sum_line_lengths(std::stringstream &is) {
  std::string line;
  size_t sumofalllinelengths{0};
-  while(std::getline(is, line)) {
+  while (std::getline(is, line)) {
    sumofalllinelengths += line.size();
  }
  return sumofalllinelengths;
 }

-inline void reset_stream(std::stringstream & is) {
+inline void reset_stream(std::stringstream &is) {
  is.clear();
-  is.seekg(0,std::ios::beg);
+  is.seekg(0, std::ios::beg);
 }

-
-
-bool bench(const char *filename, bool verbose, bool just_data, double repeat_multiplier) {
+bool bench(const char *filename, bool verbose, bool just_data,
+           double repeat_multiplier) {
  simdjson::padded_string p;
  auto error = simdjson::padded_string::load(filename).get(p);
  if (error) {
-    std::cerr << "Could not load the file " << filename << ": " << error << std::endl;
+    std::cerr << "Could not load the file " << filename << ": " << error
+              << std::endl;
    return false;
  }

-  int repeat = static_cast<int>((50000000 * repeat_multiplier) / static_cast<double>(p.size()));
-  if (repeat < 10) { repeat = 10; }
+  int repeat = static_cast<int>((50000000 * repeat_multiplier) /
+                                static_cast<double>(p.size()));
+  if (repeat < 10) {
+    repeat = 10;
+  }
  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
  if (verbose) {
    std::cout << "Input " << filename << " has ";
@@ -104,68 +115,98 @@ bool bench(const char *filename, bool verbose, bool just_data, double repeat_mul
  }
  size_t volume = p.size();
  if (just_data) {
-    printf("%-42s %20s %20s %20s %20s \n", "name", "cycles_per_byte",
-           "cycles_per_byte_err", "gb_per_s", "gb_per_s_err");
+    std::printf("%-42s %20s %20s %20s %20s \n", "name", "cycles_per_byte",
+                "cycles_per_byte_err", "gb_per_s", "gb_per_s_err");
  }
  if (!just_data) {
-    const std::string inputcopy(p.data(), p.data()+p.size());
+    const std::string inputcopy(p.data(), p.data() + p.size());
    std::stringstream is;
    is.str(inputcopy);
    const size_t lc = sum_line_lengths(is);
-    BEST_TIME("getline ",sum_line_lengths(is) , lc, reset_stream(is),
-       repeat, volume, !just_data);
+    BEST_TIME("getline ", sum_line_lengths(is), lc, reset_stream(is), repeat,
+              volume, !just_data);
  }

  if (!just_data) {
-    auto parse_dynamic=[](auto& str){
-        simdjson::dom::parser parser;
-        return parser.parse(str).error();
+    auto parse_dynamic = [](auto &str) {
+      simdjson::dom::parser parser;
+      return parser.parse(str).error();
    };
-    BEST_TIME("simdjson (dynamic mem) ", parse_dynamic(p), simdjson::SUCCESS,
-              , repeat, volume, !just_data);
+    BEST_TIME("simdjson (dynamic mem) ", parse_dynamic(p), simdjson::SUCCESS, ,
+              repeat, volume, !just_data);
  }
  // (static alloc)
  simdjson::dom::parser parser;
-  BEST_TIME("simdjson ", parser.parse(p).error(), simdjson::SUCCESS, , repeat, volume,
-            !just_data);
- 
+  BEST_TIME("simdjson ", parser.parse(p).error(), simdjson::SUCCESS, , repeat,
+            volume, !just_data);
+
  rapidjson::Document d;

-  char *buffer = (char *)malloc(p.size() + 1);
-  memcpy(buffer, p.data(), p.size());
+  char *buffer = (char *)std::malloc(p.size() + 1);
+  std::memcpy(buffer, p.data(), p.size());
  buffer[p.size()] = '\0';
 #ifndef ALLPARSER
  if (!just_data)
 #endif
  {
-    memcpy(buffer, p.data(), p.size());
+    std::memcpy(buffer, p.data(), p.size());
    BEST_TIME("RapidJSON  ",
              d.Parse<kParseValidateEncodingFlag>((const char *)buffer)
                  .HasParseError(),
-              false, , repeat, volume,
-              !just_data);
+              false, , repeat, volume, !just_data);
  }
 #ifndef ALLPARSER
  if (!just_data)
 #endif
  {
-    memcpy(buffer, p.data(), p.size());
+    std::memcpy(buffer, p.data(), p.size());
    BEST_TIME("RapidJSON (accurate number parsing)  ",
-              d.Parse<kParseValidateEncodingFlag|kParseFullPrecisionFlag>((const char *)buffer)
+              d.Parse<kParseValidateEncodingFlag | kParseFullPrecisionFlag>(
+                   (const char *)buffer)
                  .HasParseError(),
-              false, , repeat, volume,
-              !just_data);
+              false, , repeat, volume, !just_data);
  }
-  BEST_TIME("RapidJSON (insitu)",
-            d.ParseInsitu<kParseValidateEncodingFlag>(buffer).HasParseError(),
-            false,
-            memcpy(buffer, p.data(), p.size()) && (buffer[p.size()] = '\0'),
-            repeat, volume, !just_data);
+  BEST_TIME(
+      "RapidJSON (insitu)",
+      d.ParseInsitu<kParseValidateEncodingFlag>(buffer).HasParseError(), false,
+      std::memcpy(buffer, p.data(), p.size()) && (buffer[p.size()] = '\0'),
+      repeat, volume, !just_data);
  BEST_TIME("RapidJSON (insitu, accurate number parsing)",
-            d.ParseInsitu<kParseValidateEncodingFlag|kParseFullPrecisionFlag>(buffer).HasParseError(),
+            d.ParseInsitu<kParseValidateEncodingFlag | kParseFullPrecisionFlag>(
+                 buffer)
+                .HasParseError(),
            false,
-            memcpy(buffer, p.data(), p.size()) && (buffer[p.size()] = '\0'),
+            std::memcpy(buffer, p.data(), p.size()) &&
+                (buffer[p.size()] = '\0'),
            repeat, volume, !just_data);
+#ifdef HAS_BOOST_JSON
+  {
+    const boost::json::string_view sv(p.data(), p.size());
+    boost::json::parser p;
+    auto execute = [&p](auto sv) -> bool {
+      boost::json::error_code ec;
+      boost::json::monotonic_resource mr;
+        p.reset( &mr );
+        p.write(sv,ec);
+       if(!ec)
+         auto jv=p.release();
+       return !!ec;
+    };
+
+    BEST_TIME("Boost.json", execute(sv), false, , repeat, volume, !just_data);
+  }
+#endif
+  {
+
+    auto execute = [&p]() -> bool {
+      yyjson_doc *doc = yyjson_read(p.data(), p.size(), 0);
+      bool is_ok = doc != nullptr;
+      yyjson_doc_free(doc);
+      return is_ok;
+    };
+
+    BEST_TIME("yyjson", execute(), true, , repeat, volume, !just_data);
+  }
 #ifndef ALLPARSER
  if (!just_data)
 #endif
@@ -173,59 +214,61 @@ bool bench(const char *filename, bool verbose, bool just_data, double repeat_mul
              sajson::parse(sajson::dynamic_allocation(),
                            sajson::mutable_string_view(p.size(), buffer))
                  .is_valid(),
-              true, memcpy(buffer, p.data(), p.size()), repeat, volume,
+              true, std::memcpy(buffer, p.data(), p.size()), repeat, volume,
              !just_data);

  size_t ast_buffer_size = p.size();
-  size_t *ast_buffer = (size_t *)malloc(ast_buffer_size * sizeof(size_t));
+  size_t *ast_buffer = (size_t *)std::malloc(ast_buffer_size * sizeof(size_t));
  //  (static alloc, insitu)
  BEST_TIME(
      "sajson",
      sajson::parse(sajson::bounded_allocation(ast_buffer, ast_buffer_size),
                    sajson::mutable_string_view(p.size(), buffer))
          .is_valid(),
-      true, memcpy(buffer, p.data(), p.size()), repeat, volume, !just_data);
+      true, std::memcpy(buffer, p.data(), p.size()), repeat, volume,
+      !just_data);

-  memcpy(buffer, p.data(), p.size());
+  std::memcpy(buffer, p.data(), p.size());
  size_t expected = json::parse(p.data(), p.data() + p.size()).size();
  BEST_TIME("nlohmann-json", json::parse(buffer, buffer + p.size()).size(),
-            expected, , repeat, volume,
-            !just_data);
+            expected, , repeat, volume, !just_data);

 #ifdef ALLPARSER
  std::string json11err;
  BEST_TIME("dropbox (json11)     ",
            ((json11::Json::parse(buffer, json11err).is_null()) ||
             (!json11err.empty())),
-            false, memcpy(buffer, p.data(), p.size()), repeat, volume,
+            false, std::memcpy(buffer, p.data(), p.size()), repeat, volume,
            !just_data);

  BEST_TIME("fastjson             ", fastjson_parse(buffer), true,
-            memcpy(buffer, p.data(), p.size()), repeat, volume, !just_data);
+            std::memcpy(buffer, p.data(), p.size()), repeat, volume,
+            !just_data);
  JsonValue value;
  JsonAllocator allocator;
  char *endptr;
  BEST_TIME("gason             ", jsonParse(buffer, &endptr, &value, allocator),
-            JSON_OK, memcpy(buffer, p.data(), p.size()), repeat, volume,
+            JSON_OK, std::memcpy(buffer, p.data(), p.size()), repeat, volume,
            !just_data);
  void *state;
  BEST_TIME("ultrajson         ",
            (UJDecode(buffer, p.size(), NULL, &state) == NULL), false,
-            memcpy(buffer, p.data(), p.size()), repeat, volume, !just_data);
+            std::memcpy(buffer, p.data(), p.size()), repeat, volume,
+            !just_data);

  {
    std::unique_ptr<jsmntok_t[]> tokens =
        std::make_unique<jsmntok_t[]>(p.size());
    jsmn_parser jparser;
    jsmn_init(&jparser);
-    memcpy(buffer, p.data(), p.size());
+    std::memcpy(buffer, p.data(), p.size());
    buffer[p.size()] = '\0';
-    BEST_TIME(
-        "jsmn           ",
-        (jsmn_parse(&jparser, buffer, p.size(), tokens.get(), static_cast<unsigned int>(p.size())) > 0),
-        true, jsmn_init(&jparser), repeat, volume, !just_data);
+    BEST_TIME("jsmn           ",
+              (jsmn_parse(&jparser, buffer, p.size(), tokens.get(),
+                          static_cast<unsigned int>(p.size())) > 0),
+              true, jsmn_init(&jparser), repeat, volume, !just_data);
  }
-  memcpy(buffer, p.data(), p.size());
+  std::memcpy(buffer, p.data(), p.size());
  buffer[p.size()] = '\0';
  cJSON *tree = cJSON_Parse(buffer);
  BEST_TIME("cJSON           ", ((tree = cJSON_Parse(buffer)) != NULL), true,
@@ -243,12 +286,13 @@ bool bench(const char *filename, bool verbose, bool just_data, double repeat_mul
 #endif
  if (!just_data)
    BEST_TIME("memcpy            ",
-              (memcpy(buffer, p.data(), p.size()) == buffer), true, , repeat,
-              volume, !just_data);
+              (std::memcpy(buffer, p.data(), p.size()) == buffer), true, ,
+              repeat, volume, !just_data);
 #ifdef __linux__
  if (!just_data) {
-    printf("\n \n <doing additional analysis with performance counters (Linux "
-           "only)>\n");
+    std::printf(
+        "\n \n <doing additional analysis with performance counters (Linux "
+        "only)>\n");
    std::vector<int> evts;
    evts.push_back(PERF_COUNT_HW_CPU_CYCLES);
    evts.push_back(PERF_COUNT_HW_INSTRUCTIONS);
@@ -265,64 +309,84 @@ bool bench(const char *filename, bool verbose, bool just_data, double repeat_mul
      unified.start();
      auto parse_error = parser.parse(p).error();
      if (parse_error)
-        printf("bug\n");
+        std::printf("bug\n");
      unified.end(results);
      std::transform(stats.begin(), stats.end(), results.begin(), stats.begin(),
                     std::plus<unsigned long long>());
    }
-    printf("simdjson : cycles %10.0f instructions %10.0f branchmisses %10.0f "
-           "cacheref %10.0f cachemisses %10.0f  bytespercachemiss %10.0f "
-           "inspercycle %10.1f insperbyte %10.1f\n",
-           static_cast<double>(stats[0]) / static_cast<double>(repeat), static_cast<double>(stats[1]) / static_cast<double>(repeat),
-           static_cast<double>(stats[2]) / static_cast<double>(repeat), static_cast<double>(stats[3]) / static_cast<double>(repeat),
-           static_cast<double>(stats[4]) / static_cast<double>(repeat), static_cast<double>(volume) * static_cast<double>(repeat) / static_cast<double>(stats[2]),
-           static_cast<double>(stats[1]) / static_cast<double>(stats[0]), static_cast<double>(stats[1]) / (static_cast<double>(volume) * static_cast<double>(repeat)));
+    std::printf(
+        "simdjson : cycles %10.0f instructions %10.0f branchmisses %10.0f "
+        "cacheref %10.0f cachemisses %10.0f  bytespercachemiss %10.0f "
+        "inspercycle %10.1f insperbyte %10.1f\n",
+        static_cast<double>(stats[0]) / static_cast<double>(repeat),
+        static_cast<double>(stats[1]) / static_cast<double>(repeat),
+        static_cast<double>(stats[2]) / static_cast<double>(repeat),
+        static_cast<double>(stats[3]) / static_cast<double>(repeat),
+        static_cast<double>(stats[4]) / static_cast<double>(repeat),
+        static_cast<double>(volume) * static_cast<double>(repeat) /
+            static_cast<double>(stats[2]),
+        static_cast<double>(stats[1]) / static_cast<double>(stats[0]),
+        static_cast<double>(stats[1]) /
+            (static_cast<double>(volume) * static_cast<double>(repeat)));

    std::fill(stats.begin(), stats.end(), 0);
    for (decltype(repeat) i = 0; i < repeat; i++) {
-      memcpy(buffer, p.data(), p.size());
+      std::memcpy(buffer, p.data(), p.size());
      buffer[p.size()] = '\0';
      unified.start();
      if (d.ParseInsitu<kParseValidateEncodingFlag>(buffer).HasParseError() !=
          false)
-        printf("bug\n");
+        std::printf("bug\n");
      unified.end(results);
      std::transform(stats.begin(), stats.end(), results.begin(), stats.begin(),
                     std::plus<unsigned long long>());
    }
-    printf("RapidJSON: cycles %10.0f instructions %10.0f branchmisses %10.0f "
-           "cacheref %10.0f cachemisses %10.0f  bytespercachemiss %10.0f "
-           "inspercycle %10.1f insperbyte %10.1f\n",
-           static_cast<double>(stats[0]) / static_cast<double>(repeat), static_cast<double>(stats[1]) / static_cast<double>(repeat),
-           static_cast<double>(stats[2]) / static_cast<double>(repeat), static_cast<double>(stats[3]) / static_cast<double>(repeat),
-           static_cast<double>(stats[4]) / static_cast<double>(repeat), static_cast<double>(volume) * static_cast<double>(repeat) / static_cast<double>(stats[2]),
-           static_cast<double>(stats[1]) / static_cast<double>(stats[0]), static_cast<double>(stats[1]) / (static_cast<double>(volume) * static_cast<double>(repeat)));
+    std::printf(
+        "RapidJSON: cycles %10.0f instructions %10.0f branchmisses %10.0f "
+        "cacheref %10.0f cachemisses %10.0f  bytespercachemiss %10.0f "
+        "inspercycle %10.1f insperbyte %10.1f\n",
+        static_cast<double>(stats[0]) / static_cast<double>(repeat),
+        static_cast<double>(stats[1]) / static_cast<double>(repeat),
+        static_cast<double>(stats[2]) / static_cast<double>(repeat),
+        static_cast<double>(stats[3]) / static_cast<double>(repeat),
+        static_cast<double>(stats[4]) / static_cast<double>(repeat),
+        static_cast<double>(volume) * static_cast<double>(repeat) /
+            static_cast<double>(stats[2]),
+        static_cast<double>(stats[1]) / static_cast<double>(stats[0]),
+        static_cast<double>(stats[1]) /
+            (static_cast<double>(volume) * static_cast<double>(repeat)));

    std::fill(stats.begin(), stats.end(), 0); // unnecessary
    for (decltype(repeat) i = 0; i < repeat; i++) {
-      memcpy(buffer, p.data(), p.size());
+      std::memcpy(buffer, p.data(), p.size());
      unified.start();
      if (sajson::parse(sajson::bounded_allocation(ast_buffer, ast_buffer_size),
                        sajson::mutable_string_view(p.size(), buffer))
              .is_valid() != true)
-        printf("bug\n");
+        std::printf("bug\n");
      unified.end(results);
      std::transform(stats.begin(), stats.end(), results.begin(), stats.begin(),
                     std::plus<unsigned long long>());
    }
-    printf("sajson   : cycles %10.0f instructions %10.0f branchmisses %10.0f "
-           "cacheref %10.0f cachemisses %10.0f  bytespercachemiss %10.0f "
-           "inspercycle %10.1f insperbyte %10.1f\n",
-           static_cast<double>(stats[0]) / static_cast<double>(repeat), static_cast<double>(stats[1]) / static_cast<double>(repeat),
-           static_cast<double>(stats[2]) / static_cast<double>(repeat), static_cast<double>(stats[3]) / static_cast<double>(repeat),
-           static_cast<double>(stats[4]) / static_cast<double>(repeat), static_cast<double>(volume) * static_cast<double>(repeat) / static_cast<double>(stats[2]),
-           static_cast<double>(stats[1]) / static_cast<double>(stats[0]), static_cast<double>(stats[1]) / (static_cast<double>(volume) * static_cast<double>(repeat)));
-
+    std::printf(
+        "sajson   : cycles %10.0f instructions %10.0f branchmisses %10.0f "
+        "cacheref %10.0f cachemisses %10.0f  bytespercachemiss %10.0f "
+        "inspercycle %10.1f insperbyte %10.1f\n",
+        static_cast<double>(stats[0]) / static_cast<double>(repeat),
+        static_cast<double>(stats[1]) / static_cast<double>(repeat),
+        static_cast<double>(stats[2]) / static_cast<double>(repeat),
+        static_cast<double>(stats[3]) / static_cast<double>(repeat),
+        static_cast<double>(stats[4]) / static_cast<double>(repeat),
+        static_cast<double>(volume) * static_cast<double>(repeat) /
+            static_cast<double>(stats[2]),
+        static_cast<double>(stats[1]) / static_cast<double>(stats[0]),
+        static_cast<double>(stats[1]) /
+            (static_cast<double>(volume) * static_cast<double>(repeat)));
  }
 #endif //  __linux__

-  free(ast_buffer);
-  free(buffer);
+  std::free(ast_buffer);
+  std::free(buffer);
  return true;
 }

@@ -349,13 +413,17 @@ int main(int argc, char *argv[]) {
    std::cerr << "Usage: " << argv[0] << " <jsonfile>" << std::endl;
    std::cerr << "Or " << argv[0] << " -v <jsonfile>" << std::endl;
    std::cerr << "The '-t' flag outputs a table." << std::endl;
-    std::cerr << "The '-r <N>' flag sets the repeat multiplier: set it above 1 to do more iterations, and below 1 to do fewer." << std::endl;
+    std::cerr << "The '-r <N>' flag sets the repeat multiplier: set it above 1 "
+                 "to do more iterations, and below 1 to do fewer."
+              << std::endl;
    exit(1);
  }
  int result = EXIT_SUCCESS;
  for (int fileind = optind; fileind < argc; fileind++) {
-    if (!bench(argv[fileind], verbose, just_data, repeat_multiplier)) { result = EXIT_FAILURE; }
-    printf("\n\n");
+    if (!bench(argv[fileind], verbose, just_data, repeat_multiplier)) {
+      result = EXIT_FAILURE;
+    }
+    std::printf("\n\n");
  }
  return result;
 }
@@ -0,0 +1,51 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "partial_tweets.h"
+
+namespace partial_tweets {
+
+using namespace simdjson;
+
+class Dom {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+
+  simdjson_really_inline const std::vector<tweet> &Result() { return tweets; }
+  simdjson_really_inline size_t ItemCount() { return tweets.size(); }
+
+private:
+  dom::parser parser{};
+  std::vector<tweet> tweets{};
+
+  simdjson_really_inline uint64_t nullable_int(dom::element element) {
+    if (element.is_null()) { return 0; }
+    return element;
+  }
+};
+
+simdjson_really_inline bool Dom::Run(const padded_string &json) {
+  tweets.clear();
+
+  for (dom::element tweet : parser.parse(json)["statuses"]) {
+    auto user = tweet["user"];
+    tweets.emplace_back(partial_tweets::tweet{
+      tweet["created_at"],
+      tweet["id"],
+      tweet["text"],
+      nullable_int(tweet["in_reply_to_status_id"]),
+      { user["id"], user["screen_name"] },
+      tweet["retweet_count"],
+      tweet["favorite_count"]
+    });
+  }
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(PartialTweets, Dom);
+
+} // namespace partial_tweets
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,64 @@
+#pragma once
+
+#include "partial_tweets.h"
+
+namespace partial_tweets {
+
+using namespace simdjson;
+
+class DomNoExcept {
+public:
+  simdjson_really_inline bool Run(const simdjson::padded_string &json) noexcept;
+
+  simdjson_really_inline const std::vector<tweet> &Result() { return tweets; }
+  simdjson_really_inline size_t ItemCount() { return tweets.size(); }
+
+private:
+  dom::parser parser{};
+  std::vector<tweet> tweets{};
+
+  simdjson_really_inline simdjson_result<uint64_t> nullable_int(simdjson_result<dom::element> result) noexcept {
+    dom::element element;
+    SIMDJSON_TRY( result.get(element) );
+    if (element.is_null()) { return 0; }
+    return element.get_uint64();
+  }
+
+  simdjson_really_inline error_code RunNoExcept(const simdjson::padded_string &json) noexcept;
+};
+
+simdjson_really_inline bool DomNoExcept::Run(const simdjson::padded_string &json) noexcept {
+  auto error = RunNoExcept(json);
+  if (error) { std::cerr << error << std::endl; return false; }
+  return true;
+}
+
+simdjson_really_inline error_code DomNoExcept::RunNoExcept(const simdjson::padded_string &json) noexcept {
+  tweets.clear();
+
+  dom::array tweet_array;
+  SIMDJSON_TRY( parser.parse(json)["statuses"].get_array().get(tweet_array) );
+
+  for (auto tweet_element : tweet_array) {
+    dom::object tweet;
+    SIMDJSON_TRY( tweet_element.get_object().get(tweet) );
+
+    dom::object user;
+    SIMDJSON_TRY( tweet["user"].get_object().get(user) );
+
+    partial_tweets::tweet t;
+    SIMDJSON_TRY( tweet["created_at"]    .get_string().get(t.created_at) );
+    SIMDJSON_TRY( tweet["id"]            .get_uint64().get(t.id) );
+    SIMDJSON_TRY( tweet["text"]          .get_string().get(t.text) );
+    SIMDJSON_TRY( nullable_int(tweet["in_reply_to_status_id"]).get(t.in_reply_to_status_id) );
+    SIMDJSON_TRY( user["id"]             .get_uint64().get(t.user.id) );
+    SIMDJSON_TRY( user["screen_name"]    .get_string().get(t.user.screen_name) );
+    SIMDJSON_TRY( tweet["retweet_count"] .get_uint64().get(t.retweet_count) );
+    SIMDJSON_TRY( tweet["favorite_count"].get_uint64().get(t.favorite_count) );
+
+    tweets.push_back(t);
+  }
+  return SUCCESS;
+}
+
+} // namespace partial_tweets
@@ -0,0 +1,93 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "partial_tweets.h"
+
+namespace partial_tweets {
+
+using namespace simdjson;
+using namespace simdjson::builtin;
+
+class Iter {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+
+  simdjson_really_inline const std::vector<tweet> &Result() { return tweets; }
+  simdjson_really_inline size_t ItemCount() { return tweets.size(); }
+
+private:
+  ondemand::parser parser{};
+  std::vector<tweet> tweets{};
+
+  simdjson_really_inline uint64_t nullable_int(ondemand::value && value) {
+    if (value.is_null()) { return 0; }
+    return std::move(value);
+  }
+
+  simdjson_really_inline twitter_user read_user(ondemand::object && user) {
+    // Move user into a local object so it gets destroyed (and moves the iterator)
+    ondemand::object u = std::move(user);
+    return { u["id"], u["screen_name"] };
+  }
+};
+
+simdjson_really_inline bool Iter::Run(const padded_string &json) {
+  tweets.clear();
+
+  // Walk the document, parsing the tweets as we go
+
+  // { "statuses":
+  auto iter = parser.iterate_raw(json).value();
+  if (!iter.start_object()   || !iter.find_field_raw("statuses")) { return false; }
+  // { "statuses": [
+  if (!iter.start_array()) { return false; }
+
+  do {
+    tweet tweet;
+
+    if (!iter.start_object()   || !iter.find_field_raw("created_at")) { return false; }
+    tweet.created_at = iter.consume_string();
+
+    if (!iter.has_next_field() || !iter.find_field_raw("id")) { return false; }
+    tweet.id = iter.consume_uint64();
+
+    if (!iter.has_next_field() || !iter.find_field_raw("text")) { return false; }
+    tweet.text = iter.consume_string();
+
+    if (!iter.has_next_field() || !iter.find_field_raw("in_reply_to_status_id")) { return false; }
+    if (!iter.is_null()) {
+      tweet.in_reply_to_status_id = iter.consume_uint64();
+    }
+
+    if (!iter.has_next_field() || !iter.find_field_raw("user")) { return false; }
+    {
+      if (!iter.start_object()   || !iter.find_field_raw("id")) { return false; }
+      tweet.user.id = iter.consume_uint64();
+
+      if (!iter.has_next_field() || !iter.find_field_raw("screen_name")) { return false; }
+      tweet.user.screen_name = iter.consume_string();
+
+      if (iter.skip_container()) { return false; } // Skip the rest of the user object
+    }
+
+    if (!iter.has_next_field() || !iter.find_field_raw("retweet_count")) { return false; }
+    tweet.retweet_count = iter.consume_uint64();
+
+    if (!iter.has_next_field() || !iter.find_field_raw("favorite_count")) { return false; }
+    tweet.favorite_count = iter.consume_uint64();
+
+    tweets.push_back(tweet);
+
+    if (iter.skip_container()) { return false; } // Skip the rest of the tweet object
+
+  } while (iter.has_next_element());
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(PartialTweets, Iter);
+
+} // namespace partial_tweets
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,65 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "partial_tweets.h"
+
+namespace partial_tweets {
+
+using namespace simdjson;
+using namespace simdjson::builtin;
+
+
+class OnDemand {
+public:
+  OnDemand() {
+    if(!displayed_implementation) {
+      std::cout << "On Demand implementation: " << builtin_implementation()->name() << std::endl;
+      displayed_implementation = true;
+    }
+  }
+  simdjson_really_inline bool Run(const padded_string &json);
+  simdjson_really_inline const std::vector<tweet> &Result() { return tweets; }
+  simdjson_really_inline size_t ItemCount() { return tweets.size(); }
+
+private:
+  ondemand::parser parser{};
+  std::vector<tweet> tweets{};
+
+  simdjson_really_inline uint64_t nullable_int(ondemand::value && value) {
+    if (value.is_null()) { return 0; }
+    return std::move(value);
+  }
+
+  simdjson_really_inline twitter_user read_user(ondemand::object && user) {
+    // Move user into a local object so it gets destroyed (and moves the iterator)
+    ondemand::object u = std::move(user);
+    return { u["id"], u["screen_name"] };
+  }
+  static inline bool displayed_implementation = false;
+};
+
+simdjson_really_inline bool OnDemand::Run(const padded_string &json) {
+  tweets.clear();
+
+  // Walk the document, parsing the tweets as we go
+  auto doc = parser.iterate(json);
+  for (ondemand::object tweet : doc["statuses"]) {
+    tweets.emplace_back(partial_tweets::tweet{
+      tweet["created_at"],
+      tweet["id"],
+      tweet["text"],
+      nullable_int(tweet["in_reply_to_status_id"]),
+      read_user(tweet["user"]),
+      tweet["retweet_count"],
+      tweet["favorite_count"]
+    });
+  }
+  return true;
+}
+
+BENCHMARK_TEMPLATE(PartialTweets, OnDemand);
+
+} // namespace partial_tweets
+
+#endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,41 @@
+#pragma once
+
+//
+// Interface
+//
+
+namespace partial_tweets {
+template<typename T> static void PartialTweets(benchmark::State &state);
+} // namespace partial_tweets
+
+//
+// Implementation
+//
+
+#include "tweet.h"
+#include <vector>
+#include "event_counter.h"
+#include "domnoexcept.h"
+#include "json_benchmark.h"
+
+namespace partial_tweets {
+
+using namespace simdjson;
+
+template<typename T> static void PartialTweets(benchmark::State &state) {
+  //
+  // Load the JSON file
+  //
+  constexpr const char *TWITTER_JSON = SIMDJSON_BENCHMARK_DATA_DIR "twitter.json";
+  error_code error;
+  padded_string json;
+  if ((error = padded_string::load(TWITTER_JSON).get(json))) {
+    std::cerr << error << std::endl;
+    state.SkipWithError("error loading");
+    return;
+  }
+
+  JsonBenchmark<T, DomNoExcept>(state, json);
+}
+
+} // namespace partial_tweets
@@ -0,0 +1,69 @@
+#pragma once
+
+
+#include "partial_tweets.h"
+#include "sax_tweet_reader_visitor.h"
+
+namespace partial_tweets {
+
+using namespace simdjson;
+using namespace simdjson::builtin;
+using namespace simdjson::builtin::stage2;
+
+class Sax {
+public:
+  simdjson_really_inline bool Run(const padded_string &json) noexcept;
+
+  simdjson_really_inline const std::vector<tweet> &Result() { return tweets; }
+  simdjson_really_inline size_t ItemCount() { return tweets.size(); }
+
+private:
+  simdjson_really_inline error_code RunNoExcept(const padded_string &json) noexcept;
+  error_code Allocate(size_t new_capacity);
+  std::unique_ptr<uint8_t[]> string_buf{};
+  size_t capacity{};
+  dom_parser_implementation dom_parser{};
+  std::vector<tweet> tweets{};
+};
+
+// NOTE: this assumes the dom_parser is already allocated
+bool Sax::Run(const padded_string &json) noexcept {
+  auto error = RunNoExcept(json);
+  if (error) { std::cerr << error << std::endl; return false; }
+  return true;
+}
+
+error_code Sax::RunNoExcept(const padded_string &json) noexcept {
+  tweets.clear();
+
+  // Allocate capacity if needed
+  if (capacity < json.size()) {
+    SIMDJSON_TRY( Allocate(json.size()) );
+  }
+
+  // Run stage 1 first.
+  SIMDJSON_TRY( dom_parser.stage1((uint8_t *)json.data(), json.size(), false) );
+
+  // Then walk the document, parsing the tweets as we go
+  json_iterator iter(dom_parser, 0);
+  sax_tweet_reader_visitor visitor(tweets, string_buf.get());
+  SIMDJSON_TRY( iter.walk_document<false>(visitor) );
+  return SUCCESS;
+}
+
+error_code Sax::Allocate(size_t new_capacity) {
+  // string_capacity copied from document::allocate
+  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + SIMDJSON_PADDING, 64);
+  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
+  if (auto error = dom_parser.set_capacity(new_capacity)) { return error; }
+  if (capacity == 0) { // set max depth the first time only
+    if (auto error = dom_parser.set_max_depth(DEFAULT_MAX_DEPTH)) { return error; }
+  }
+  capacity = new_capacity;
+  return SUCCESS;
+}
+
+BENCHMARK_TEMPLATE(PartialTweets, Sax);
+
+} // namespace partial_tweets
+
@@ -1,21 +1,18 @@
-#ifndef TWITTER_SAX_TWEET_READER_VISITOR_H
-#define TWITTER_SAX_TWEET_READER_VISITOR_H
+#pragma once

 #include "simdjson.h"
 #include "tweet.h"
 #include <vector>

-SIMDJSON_TARGET_HASWELL
-
-namespace twitter {
+namespace partial_tweets {

 using namespace simdjson;
-using namespace haswell;
-using namespace haswell::stage2;
+using namespace simdjson::builtin;
+using namespace simdjson::builtin::stage2;

 struct sax_tweet_reader_visitor {
 public:
-  sax_tweet_reader_visitor(std::vector<tweet> &_tweets, uint8_t *string_buf);
+  simdjson_really_inline sax_tweet_reader_visitor(std::vector<tweet> &tweets, uint8_t *string_buf);

  simdjson_really_inline error_code visit_document_start(json_iterator &iter);
  simdjson_really_inline error_code visit_object_start(json_iterator &iter);
@@ -68,8 +65,8 @@ private:
    field_type type{field_type::any};
  };

-  containers container{containers::document};
  std::vector<tweet> &tweets;
+  containers container{containers::document};
  uint8_t *current_string_buf_loc;
  const uint8_t *current_key{};

@@ -94,9 +91,9 @@ private:
  static field_lookup fields;
 }; // sax_tweet_reader_visitor

-sax_tweet_reader_visitor::sax_tweet_reader_visitor(std::vector<tweet> &_tweets, uint8_t *string_buf)
+simdjson_really_inline sax_tweet_reader_visitor::sax_tweet_reader_visitor(std::vector<tweet> &_tweets, uint8_t *_string_buf)
  : tweets{_tweets},
-    current_string_buf_loc{string_buf} {
+    current_string_buf_loc{_string_buf} {
 }

 simdjson_really_inline error_code sax_tweet_reader_visitor::visit_document_start(json_iterator &iter) {
@@ -112,6 +109,7 @@ simdjson_really_inline error_code sax_tweet_reader_visitor::visit_array_start(js
    switch (fields.get(current_key, container).type) {
      case field_type::array: // { "statuses": [
        start_container(iter);
+        current_key = nullptr;
        return SUCCESS;
      case field_type::any:
        return SUCCESS;
@@ -190,6 +188,7 @@ simdjson_really_inline error_code sax_tweet_reader_visitor::visit_primitive(json
        iter.log_error("unexpected primitive");
        return INCORRECT_TYPE;
    }
+    current_key = nullptr;
  }

  // If it's not a field, it's a child of an array.
@@ -202,16 +201,17 @@ simdjson_really_inline error_code sax_tweet_reader_visitor::visit_array_end(json
  return SUCCESS;
 }
 simdjson_really_inline error_code sax_tweet_reader_visitor::visit_object_end(json_iterator &iter) {
+  current_key = nullptr;
  if (in_container(iter)) { end_container(iter); }
  return SUCCESS;
 }

-simdjson_really_inline error_code sax_tweet_reader_visitor::visit_document_end(json_iterator &iter) {
-  iter.log_end_value("document");
+simdjson_really_inline error_code sax_tweet_reader_visitor::visit_document_end(json_iterator &) {
  return SUCCESS;
 }

 simdjson_really_inline error_code sax_tweet_reader_visitor::visit_empty_array(json_iterator &) {
+  current_key = nullptr;
  return SUCCESS;
 }
 simdjson_really_inline error_code sax_tweet_reader_visitor::visit_empty_object(json_iterator &) {
@@ -233,15 +233,15 @@ simdjson_really_inline bool sax_tweet_reader_visitor::in_container_child(json_it
 simdjson_really_inline void sax_tweet_reader_visitor::start_container(json_iterator &iter) {
  SIMDJSON_ASSUME(iter.depth <= MAX_SUPPORTED_DEPTH); // Asserts in debug mode
  container = containers(iter.depth);
-  if (logger::LOG_ENABLED) { iter.log_start_value(STATE_NAMES[iter.depth]); }
+  if (logger::LOG_ENABLED) { iter.log_value(STATE_NAMES[iter.depth]); }
+  if (container == containers::tweet) { tweets.push_back({}); }
 }
-simdjson_really_inline void sax_tweet_reader_visitor::end_container(json_iterator &iter) {
-  if (logger::LOG_ENABLED) { iter.log_end_value(STATE_NAMES[int(container)]); }
+simdjson_really_inline void sax_tweet_reader_visitor::end_container(json_iterator &) {
  container = containers(int(container) - 1);
 }
 simdjson_really_inline error_code sax_tweet_reader_visitor::parse_nullable_unsigned(json_iterator &iter, const uint8_t *value, const field &f) {
  iter.log_value(f.key);
-  auto i = reinterpret_cast<uint64_t *>(reinterpret_cast<char *>(&tweets.back() + f.offset));
+  auto i = reinterpret_cast<uint64_t *>(reinterpret_cast<char *>(&tweets.back()) + f.offset);
  if (auto error = numberparsing::parse_unsigned(value).get(*i)) {
    // If number parsing failed, check if it's null before returning the error
    if (!atomparsing::is_valid_null_atom(value)) { iter.log_error("expected number or null"); return error; }
@@ -251,12 +251,12 @@ simdjson_really_inline error_code sax_tweet_reader_visitor::parse_nullable_unsig
 }
 simdjson_really_inline error_code sax_tweet_reader_visitor::parse_unsigned(json_iterator &iter, const uint8_t *value, const field &f) {
  iter.log_value(f.key);
-  auto i = reinterpret_cast<uint64_t *>(reinterpret_cast<char *>(&tweets.back() + f.offset));
+  auto i = reinterpret_cast<uint64_t *>(reinterpret_cast<char *>(&tweets.back()) + f.offset);
  return numberparsing::parse_unsigned(value).get(*i);
 }
 simdjson_really_inline error_code sax_tweet_reader_visitor::parse_string(json_iterator &iter, const uint8_t *value, const field &f) {
  iter.log_value(f.key);
-  auto s = reinterpret_cast<std::string_view *>(reinterpret_cast<char *>(&tweets.back() + f.offset));
+  auto s = reinterpret_cast<std::string_view *>(reinterpret_cast<char *>(&tweets.back()) + f.offset);
  return stringparsing::parse_string_to_buffer(value, current_string_buf_loc, *s);
 }

@@ -291,13 +291,12 @@ simdjson_really_inline void sax_tweet_reader_visitor::field_lookup::neg(const ch
  auto index = hash(key, depth);
  if (entries[index].key) {
    fprintf(stderr, "%s (depth %d) conflicts with %s (depth %d) !\n", key, depth, entries[index].key, int(entries[index].container));
-    assert(false);
  }
 }

 sax_tweet_reader_visitor::field_lookup::field_lookup() {
-  add("\"statuses\"", strlen("\"statuses\""), containers::top_object, field_type::array, 0); // { "statuses": [...]
-  #define TWEET_FIELD(KEY, TYPE) add("\"" #KEY "\"", strlen("\"" #KEY "\""), containers::tweet, TYPE, offsetof(tweet, KEY));
+  add("\"statuses\"", std::strlen("\"statuses\""), containers::top_object, field_type::array, 0); // { "statuses": [...]
+  #define TWEET_FIELD(KEY, TYPE) add("\"" #KEY "\"", std::strlen("\"" #KEY "\""), containers::tweet, TYPE, offsetof(tweet, KEY));
  TWEET_FIELD(id, field_type::unsigned_integer);
  TWEET_FIELD(in_reply_to_status_id, field_type::nullable_unsigned_integer);
  TWEET_FIELD(retweet_count, field_type::unsigned_integer);
@@ -306,7 +305,7 @@ sax_tweet_reader_visitor::field_lookup::field_lookup() {
  TWEET_FIELD(created_at, field_type::string);
  TWEET_FIELD(user, field_type::object)
  #undef TWEET_FIELD
-  #define USER_FIELD(KEY, TYPE) add("\"" #KEY "\"", strlen("\"" #KEY "\""), containers::user, TYPE, offsetof(tweet, user)+offsetof(twitter_user, KEY));
+  #define USER_FIELD(KEY, TYPE) add("\"" #KEY "\"", std::strlen("\"" #KEY "\""), containers::user, TYPE, offsetof(tweet, user)+offsetof(twitter_user, KEY));
  USER_FIELD(id, field_type::unsigned_integer);
  USER_FIELD(screen_name, field_type::string);
  #undef USER_FIELD
@@ -503,7 +502,7 @@ sax_tweet_reader_visitor::field_lookup::field_lookup() {
 //   for (int a=0;a<4;a++) {
 //     for (int b=0;b<4;b++) {
 //       for (int c=0;c<4;c++) {
-//         twitter::sax_tweet_reader_visitor::field_lookup fields(a,b,c);
+//         sax_tweet_reader_visitor::field_lookup fields(a,b,c);
 //         if (fields.collision_count) { continue; }
 //         if (fields.zero_emission) { continue; }
 //         if (fields.conflict_count < min_count) { printf("min=%d,%d,%d (%d)", a, b, c, fields.conflict_count); }
@@ -512,8 +511,4 @@ sax_tweet_reader_visitor::field_lookup::field_lookup() {
 //   }
 // }

-} // namespace twitter
-
-SIMDJSON_UNTARGET_REGION
-
-#endif // TWITTER_SAX_TWEET_READER_VISITOR_H
+} // namespace partial_tweets
@@ -0,0 +1,57 @@
+#pragma once
+
+#include "simdjson.h"
+#include "twitter_user.h"
+
+namespace partial_tweets {
+
+// {
+//   "statuses": [
+//     {
+//       "created_at": "Sun Aug 31 00:29:15 +0000 2014",
+//       "id": 505874924095815700,
+//       "text": "@aym0566x \n\n名前:前田あゆみ\n第一印象:なんか怖っ！\n今の印象:とりあえずキモい。噛み合わない\n好きなところ:ぶすでキモいとこ😋✨✨\n思い出:んーーー、ありすぎ😊❤️\nLINE交換できる？:あぁ……ごめん✋\nトプ画をみて:照れますがな😘✨\n一言:お前は一生もんのダチ💖",
+//       "in_reply_to_status_id": null,
+//       "user": {
+//         "id": 1186275104,
+//         "screen_name": "ayuu0123"
+//       },
+//       "retweet_count": 0,
+//       "favorite_count": 0
+//     }
+//   ]
+// }
+
+struct tweet {
+  std::string_view created_at{};
+  uint64_t id{};
+  std::string_view text{};
+  uint64_t in_reply_to_status_id{};
+  twitter_user user{};
+  uint64_t retweet_count{};
+  uint64_t favorite_count{};
+  simdjson_really_inline bool operator==(const tweet &other) const {
+    return created_at == other.created_at &&
+           id == other.id &&
+           text == other.text &&
+           in_reply_to_status_id == other.in_reply_to_status_id &&
+           user == other.user &&
+           retweet_count == other.retweet_count &&
+           favorite_count == other.favorite_count;
+  }
+  simdjson_really_inline bool operator!=(const tweet &other) const { return !(*this == other); }
+};
+
+simdjson_unused static std::ostream &operator<<(std::ostream &o, const tweet &t) {
+  o << "created_at: " << t.created_at << std::endl;
+  o << "id: " << t.id << std::endl;
+  o << "text: " << t.text << std::endl;
+  o << "in_reply_to_status_id: " << t.in_reply_to_status_id << std::endl;
+  o << "user.id: " << t.user.id << std::endl;
+  o << "user.screen_name: " << t.user.screen_name << std::endl;
+  o << "retweet_count: " << t.retweet_count << std::endl;
+  o << "favorite_count: " << t.favorite_count << std::endl;
+  return o;
+}
+
+} // namespace partial_tweets
@@ -0,0 +1,16 @@
+#pragma once
+#include "simdjson.h"
+
+namespace partial_tweets {
+
+struct twitter_user {
+  uint64_t id{};
+  std::string_view screen_name{};
+
+  bool operator==(const twitter_user &other) const {
+    return id == other.id &&
+           screen_name == other.screen_name;
+  }
+};
+
+} // namespace partial_tweets
@@ -1,67 +0,0 @@
-#ifndef TWITTER_SAX_TWEET_READER_H
-#define TWITTER_SAX_TWEET_READER_H
-
-#include "simdjson.h"
-#include "sax_tweet_reader_visitor.h"
-#include "tweet.h"
-#include <vector>
-
-SIMDJSON_TARGET_HASWELL
-
-namespace twitter {
-namespace {
-
-using namespace simdjson;
-using namespace haswell;
-using namespace haswell::stage2;
-
-struct sax_tweet_reader {
-  std::vector<tweet> tweets;
-  std::unique_ptr<uint8_t[]> string_buf;
-  size_t capacity;
-  dom_parser_implementation dom_parser;
-
-  sax_tweet_reader();
-  error_code set_capacity(size_t new_capacity);
-  error_code read_tweets(padded_string &json);
-}; // struct tweet_reader
-
-sax_tweet_reader::sax_tweet_reader() : tweets{}, string_buf{}, capacity{0}, dom_parser() {
-}
-
-error_code sax_tweet_reader::set_capacity(size_t new_capacity) {
-  // string_capacity copied from document::allocate
-  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + 32, 64);
-  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
-  if (auto error = dom_parser.set_capacity(new_capacity)) { return error; }
-  if (capacity == 0) { // set max depth the first time only
-    if (auto error = dom_parser.set_max_depth(DEFAULT_MAX_DEPTH)) { return error; }
-  }
-  capacity = new_capacity;
-  return SUCCESS;
-}
-
-// NOTE: this assumes the dom_parser is already allocated
-error_code sax_tweet_reader::read_tweets(padded_string &json) {
-  // Allocate capacity if needed
-  tweets.clear();
-  if (capacity < json.size()) {
-    if (auto error = set_capacity(capacity)) { return error; }
-  }
-
-  // Run stage 1 first.
-  if (auto error = dom_parser.stage1((uint8_t *)json.data(), json.size(), false)) { return error; }
-
-  // Then walk the document, parsing the tweets as we go
-  json_iterator iter(dom_parser, 0);
-  sax_tweet_reader_visitor visitor(tweets, string_buf.get());
-  if (auto error = iter.walk_document<false>(visitor)) { return error; }
-  return SUCCESS;
-}
-
-} // unnamed namespace
-} // namespace twitter
-
-SIMDJSON_UNTARGET_REGION
-
-#endif // TWITTER_SAX_TWEET_READER_H
@@ -1,21 +0,0 @@
-#ifndef TWEET_H
-#define TWEET_H
-
-#include "simdjson.h"
-#include "twitter_user.h"
-
-namespace twitter {
-
-struct tweet {
-  uint64_t id{};
-  std::string_view text{};
-  std::string_view created_at{};
-  uint64_t in_reply_to_status_id{};
-  uint64_t retweet_count{};
-  uint64_t favorite_count{};
-  twitter_user user{};
-};
-
-} // namespace twitter
-
-#endif // TWEET_H
@@ -1,15 +0,0 @@
-#ifndef TWITTER_USER_H
-#define TWITTER_USER_H
-
-#include "simdjson.h"
-
-namespace twitter {
-
-struct twitter_user {
-  uint64_t id{};
-  std::string_view screen_name{};
-};
-
-} // namespace twitter
-
-#endif // TWITTER_USER_H
@@ -1,6 +1,6 @@

 if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
-  message (STATUS "The simdjson repository appears to be standalone.")  
+  message (STATUS "The simdjson repository appears to be standalone.")
  option(SIMDJSON_JUST_LIBRARY "Build just the library, omit tests, tools and benchmarks" OFF)
  message (STATUS "By default, we attempt to build everything.")
 else()
@@ -9,14 +9,6 @@ else()
  message (STATUS "By default, we just build the library.")
 endif()

-if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
-  set(SIMDJSON_IS_UNDER_GIT ON CACHE BOOL  "Whether cmake is under git control")
-  message( STATUS "The simdjson repository appears to be under git." )
-else()
-  set(SIMDJSON_IS_UNDER_GIT OFF CACHE BOOL  "Whether cmake is under git control")
-  message( STATUS "The simdjson repository does not appear to be under git." )
-endif()
-
 #
 # Flags used by exes and by the simdjson library (project-wide flags)
 #
@@ -35,6 +27,15 @@ if(SIMDJSON_SANITIZE)
  endif()
 endif()

+if(SIMDJSON_SANITIZE_THREADS)
+  target_compile_options(simdjson-flags INTERFACE -fsanitize=thread -fsanitize=undefined -fno-sanitize-recover=all)
+  target_link_libraries(simdjson-flags INTERFACE -fsanitize=thread -fsanitize=undefined -fno-sanitize-recover=all)
+
+  # Ubuntu bug for GCC 5.0+ (safe for all versions)
+  if (CMAKE_COMPILER_IS_GNUCC)
+    target_link_libraries(simdjson-flags INTERFACE -fuse-ld=gold)
+  endif()
+endif()

 if (NOT CMAKE_BUILD_TYPE)
  message(STATUS "No build type selected, default to Release")
@@ -50,12 +51,6 @@ else()
  option(SIMDJSON_BUILD_STATIC "Build a static library" OFF) # turning it on disables the production of a dynamic library
  option(SIMDJSON_USE_LIBCPP "Use the libc++ library" OFF)
 endif()
-option(SIMDJSON_COMPETITION "Compile competitive benchmarks" ON)
-
-option(SIMDJSON_GOOGLE_BENCHMARKS "compile the Google Benchmark benchmarks" ON)
-if(SIMDJSON_COMPETITION)
-  message(STATUS "Using SIMDJSON_GOOGLE_BENCHMARKS")
-endif()

 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/tools/cmake")

@@ -85,41 +80,120 @@ else()
  target_compile_options(simdjson-internal-flags INTERFACE /WX /W3 /sdl /w34714) # https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-4-c4714?view=vs-2019
 endif()
 if(SIMDJSON_VISUAL_STUDIO_BUILD_WITH_DEBUG_INFO_FOR_PROFILING)
-  target_link_options(simdjson-flags  INTERFACE    /DEBUG ) 
+  target_link_options(simdjson-flags  INTERFACE    /DEBUG )
  target_compile_options(simdjson-flags INTERFACE  /Zi)
 endif()
 else()
-  target_compile_options(simdjson-internal-flags INTERFACE -fPIC)
+  if(NOT WIN32)
+    target_compile_options(simdjson-internal-flags INTERFACE -fPIC)
+  endif()
  target_compile_options(simdjson-internal-flags INTERFACE -Werror -Wall -Wextra -Weffc++)
  target_compile_options(simdjson-internal-flags INTERFACE -Wsign-compare -Wshadow -Wwrite-strings -Wpointer-arith -Winit-self -Wconversion -Wno-sign-conversion)
 endif()

+#
 # Optional flags
+#
+
+#
+# Implementation selection
+#
+set(SIMDJSON_ALL_IMPLEMENTATIONS "fallback;westmere;haswell;arm64;ppc64")
+
+set(SIMDJSON_IMPLEMENTATION "" CACHE STRING "Semicolon-separated list of implementations to include (${SIMDJSON_ALL_IMPLEMENTATIONS}). If this is not set, any implementations that are supported at compile time and may be selected at runtime will be included.")
+foreach(implementation ${SIMDJSON_IMPLEMENTATION})
+  if(NOT (implementation IN_LIST SIMDJSON_ALL_IMPLEMENTATIONS))
+    message(ERROR "Implementation ${implementation} not supported by simdjson. Possible implementations: ${SIMDJSON_ALL_IMPLEMENTATIONS}")
+  endif()
+endforeach(implementation)
+
+set(SIMDJSON_EXCLUDE_IMPLEMENTATION "" CACHE STRING "Semicolon-separated list of implementations to exclude (haswell/westmere/arm64/ppc64/fallback). By default, excludes any implementations that are unsupported at compile time or cannot be selected at runtime.")
+foreach(implementation ${SIMDJSON_EXCLUDE_IMPLEMENTATION})
+  if(NOT (implementation IN_LIST SIMDJSON_ALL_IMPLEMENTATIONS))
+    message(ERROR "Implementation ${implementation} not supported by simdjson. Possible implementations: ${SIMDJSON_ALL_IMPLEMENTATIONS}")
+  endif()
+endforeach(implementation)
+
+foreach(implementation ${SIMDJSON_ALL_IMPLEMENTATIONS})
+  string(TOUPPER ${implementation} implementation_upper)
+  if(implementation IN_LIST SIMDJSON_EXCLUDE_IMPLEMENTATION)
+    message(STATUS "Excluding implementation ${implementation} due to SIMDJSON_EXCLUDE_IMPLEMENTATION=${SIMDJSON_EXCLUDE_IMPLEMENTATION}")
+    target_compile_definitions(simdjson-flags INTERFACE "SIMDJSON_IMPLEMENTATION_${implementation_upper}=0")
+  elseif(implementation IN_LIST SIMDJSON_IMPLEMENTATION)
+    message(STATUS "Including implementation ${implementation} due to SIMDJSON_IMPLEMENTATION=${SIMDJSON_IMPLEMENTATION}")
+    target_compile_definitions(simdjson-flags INTERFACE "SIMDJSON_IMPLEMENTATION_${implementation_upper}=1")
+  elseif(SIMDJSON_IMPLEMENTATION)
+    message(STATUS "Excluding implementation ${implementation} due to SIMDJSON_IMPLEMENTATION=${SIMDJSON_IMPLEMENTATION}")
+    target_compile_definitions(simdjson-flags INTERFACE "SIMDJSON_IMPLEMENTATION_${implementation_upper}=0")
+  endif()
+endforeach(implementation)
+
+# TODO make it so this generates the necessary compiler flags to select the given implementation as the builtin automatically!
+option(SIMDJSON_BUILTIN_IMPLEMENTATION "Select the implementation that will be used for user code. Defaults to the most universal implementation in SIMDJSON_IMPLEMENTATION (in the order ${SIMDJSON_ALL_IMPLEMENTATIONS}) if specified; otherwise, by default the compiler will pick the best implementation that can always be selected given the compiler flags." "")
+if(SIMDJSON_BUILTIN_IMPLEMENTATION)
+  target_compile_definitions(simdjson-flags INTERFACE "SIMDJSON_BUILTIN_IMPLEMENTATION=${SIMDJSON_BUILTIN_IMPLEMENTATION}")
+else()
+  # Pick the most universal implementation out of the selected implementations (if any)
+  foreach(implementation ${SIMDJSON_ALL_IMPLEMENTATIONS})
+    if(implementation IN_LIST SIMDJSON_IMPLEMENTATION AND NOT (implementation IN_LIST SIMDJSON_EXCLUDE_IMPLEMENTATION))
+      message(STATUS "Selected implementation ${implementation} as builtin implementation based on ${SIMDJSON_IMPLEMENTATION}.")
+      target_compile_definitions(simdjson-flags INTERFACE "SIMDJSON_BUILTIN_IMPLEMENTATION=${implementation}")
+      break()
+    endif()
+  endforeach(implementation)
+endif(SIMDJSON_BUILTIN_IMPLEMENTATION)
+
 option(SIMDJSON_IMPLEMENTATION_HASWELL "Include the haswell implementation" ON)
 if(NOT SIMDJSON_IMPLEMENTATION_HASWELL)
-  target_compile_definitions(simdjson-internal-flags INTERFACE SIMDJSON_IMPLEMENTATION_HASWELL=0)
+  message(DEPRECATION "SIMDJSON_IMPLEMENTATION_HASWELL is deprecated. Use SIMDJSON_IMPLEMENTATION=-haswell instead.")
+  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_IMPLEMENTATION_HASWELL=0)
 endif()
 option(SIMDJSON_IMPLEMENTATION_WESTMERE "Include the westmere implementation" ON)
 if(NOT SIMDJSON_IMPLEMENTATION_WESTMERE)
-  target_compile_definitions(simdjson-internal-flags INTERFACE SIMDJSON_IMPLEMENTATION_WESTMERE=0)
+  message(DEPRECATION "SIMDJSON_IMPLEMENTATION_WESTMERE is deprecated. SIMDJSON_IMPLEMENTATION=-westmere instead.")
+  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_IMPLEMENTATION_WESTMERE=0)
 endif()
 option(SIMDJSON_IMPLEMENTATION_ARM64 "Include the arm64 implementation" ON)
 if(NOT SIMDJSON_IMPLEMENTATION_ARM64)
-  target_compile_definitions(simdjson-internal-flags INTERFACE SIMDJSON_IMPLEMENTATION_ARM64=0)
+  message(DEPRECATION "SIMDJSON_IMPLEMENTATION_ARM64 is deprecated. Use SIMDJSON_IMPLEMENTATION=-arm64 instead.")
+  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_IMPLEMENTATION_ARM64=0)
+endif()
+option(SIMDJSON_IMPLEMENTATION_PPC64 "Include the arm64 implementation" ON)
+if(NOT SIMDJSON_IMPLEMENTATION_PPC64)
+  message(DEPRECATION "SIMDJSON_IMPLEMENTATION_PPC64 is deprecated. Use SIMDJSON_IMPLEMENTATION=-ppc64 instead.")
+  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_IMPLEMENTATION_PPC64=0)
 endif()
 option(SIMDJSON_IMPLEMENTATION_FALLBACK "Include the fallback implementation" ON)
 if(NOT SIMDJSON_IMPLEMENTATION_FALLBACK)
-  target_compile_definitions(simdjson-internal-flags INTERFACE SIMDJSON_IMPLEMENTATION_FALLBACK=0)
+  message(DEPRECATION "SIMDJSON_IMPLEMENTATION_FALLBACK is deprecated. Use SIMDJSON_IMPLEMENTATION=-fallback instead.")
+  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_IMPLEMENTATION_FALLBACK=0)
 endif()

-option(SIMDJSON_BASH "Allow usage of bash within CMake" ON)
+#
+# Other optional flags
+#
+option(SIMDJSON_ONDEMAND_SAFETY_RAILS "Validate ondemand user code at runtime to ensure it is being used correctly. Defaults to ON for debug builds, OFF for release builds." $<IF:$<CONFIG:DEBUG>,ON,OFF>)
+if(SIMDJSON_ONDEMAND_SAFETY_RAILS)
+  message(STATUS "Ondemand safety rails enabled. Ondemand user code will be checked at runtime. This will be slower than normal!")
+  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_ONDEMAND_SAFETY_RAILS)
+endif(SIMDJSON_ONDEMAND_SAFETY_RAILS)

-option(SIMDJSON_GIT "Allow usage of git within CMake" ON)
+option(SIMDJSON_BASH "Allow usage of bash within CMake" ON)

 option(SIMDJSON_EXCEPTIONS "Enable simdjson's exception-throwing interface" ON)
 if(NOT SIMDJSON_EXCEPTIONS)
  message(STATUS "simdjson exception interface turned off. Code that does not check error codes will not compile.")
-  target_compile_definitions(simdjson-internal-flags INTERFACE SIMDJSON_EXCEPTIONS=0)
+  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_EXCEPTIONS=0)
+  if(MSVC)
+    # CMake currently /EHsc as a default flag in CMAKE_CXX_FLAGS on MSVC. Replacing this with a more general abstraction is a WIP (see https://gitlab.kitware.com/cmake/cmake/-/issues/20610)
+    # /EHs enables standard C++ stack unwinding when catching exceptions (non-structured exception handling)
+    # /EHc used in conjection with /EHs indicates that extern "C" functions never throw (terminate-on-throw)
+    # Here, we disable both with the - argument negation operator
+    string(REPLACE "/EHsc" "/EHs-c-" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+
+    # Because we cannot change the flag above on an invidual target (yet), the definition below must similarly be added globally
+    add_definitions(-D_HAS_EXCEPTIONS=0)
+  endif()
 endif()

 option(SIMDJSON_ENABLE_THREADS "Link with thread support" ON)
@@ -133,6 +207,16 @@ if(SIMDJSON_ENABLE_THREADS)
  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_THREADS_ENABLED=1) # This will be set in the code automatically.
 endif()

+option(SIMDJSON_VERBOSE_LOGGING, "Enable verbose logging for internal simdjson library development." OFF)
+if (SIMDJSON_VERBOSE_LOGGING)
+  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_VERBOSE_LOGGING=1)
+endif()
+
+option(SIMDJSON_DISABLE_DEPRECATED_API "Disables deprecated APIs" Off)
+if (SIMDJSON_DISABLE_DEPRECATED_API)
+    target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_DISABLE_DEPRECATED_API=1)
+endif()
+
 if(SIMDJSON_USE_LIBCPP)
  target_link_libraries(simdjson-flags INTERFACE -stdlib=libc++ -lc++abi)
  # instead of the above line, we could have used
@@ -0,0 +1 @@
+.cache/
@@ -1,89 +1,110 @@
-# Initializes a git submodule if it hasn't been initialized before
+include(import.cmake)

+option(SIMDJSON_COMPETITION "Compile competitive benchmarks" ON)
+option(SIMDJSON_GOOGLE_BENCHMARKS "compile the Google Benchmark benchmarks" ON)

-find_package(Git QUIET) # We want the library to build even if git is missing
-if ((Git_FOUND) AND SIMDJSON_GIT AND (SIMDJSON_IS_UNDER_GIT))
-  message(STATUS "Git is available.")
-  # Does NOT attempt to update or otherwise modify git submodules that are already initialized.
-  function(initialize_submodule DIRECTORY)
-    if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${DIRECTORY}/.git)
-      message(STATUS "${CMAKE_CURRENT_SOURCE_DIR}/${DIRECTORY}/.git does not exist. Initializing ${DIRECTORY} submodule ...")
-      execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init ${CMAKE_CURRENT_SOURCE_DIR}/${DIRECTORY}
-                      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-                      RESULT_VARIABLE GIT_EXIT_CODE)
-      if(NOT GIT_EXIT_CODE EQUAL "0")
-        message(FATAL_ERROR "${GIT_EXECUTABLE} submodule update --init dependencies/${DIRECTORY} failed with exit code ${GIT_EXIT_CODE}, please checkout submodules")
-      endif()
-    endif()
-  endfunction(initialize_submodule)
+if(SIMDJSON_GOOGLE_BENCHMARKS)
+  set_off(BENCHMARK_ENABLE_TESTING)
+  set_off(BENCHMARK_ENABLE_INSTALL)

-  if (SIMDJSON_GOOGLE_BENCHMARKS)
-    message (STATUS "'SIMDJSON_GOOGLE_BENCHMARKS' is requested, configuring..." )
-    option(BENCHMARK_ENABLE_TESTING OFF)
-    set(BENCHMARK_ENABLE_TESTING OFF)
-    option(BENCHMARK_ENABLE_INSTALL OFF)
-    set(BENCHMARK_ENABLE_INSTALL OFF)
-    initialize_submodule(benchmark)
-    add_subdirectory(benchmark)
+  import_dependency(google_benchmarks google/benchmark 8982e1e)
+  add_dependency(google_benchmarks)
+endif()
+
+# This prevents variables declared with set() from unnecessarily escaping and
+# should not be called more than once
+function(competition_scope_)
+  # boost json in standalone mode requires C++17 string_view
+  include(CheckCXXSourceCompiles)
+  check_cxx_source_compiles("#include <string_view>\n#if __cpp_lib_string_view < 201606\n#error no string view support\n#endif\nint main(){}" USE_BOOST_JSON)
+  if(USE_BOOST_JSON)
+  import_dependency(boostjson boostorg/json ee8d72d8502b409b5561200299cad30ccdb91415)
+  add_library(boostjson STATIC "${boostjson_SOURCE_DIR}/src/src.cpp")
+  target_compile_definitions(boostjson PUBLIC BOOST_JSON_STANDALONE)
+  target_include_directories(boostjson SYSTEM PUBLIC
+          "${boostjson_SOURCE_DIR}/include")
  endif()

-  if (SIMDJSON_COMPETITION)
-    initialize_submodule(cJSON)
-    add_library(competition-cJSON INTERFACE)
-    target_include_directories(competition-cJSON INTERFACE cJSON)
+  import_dependency(cjson DaveGamble/cJSON c69134d)
+  add_library(cjson STATIC "${cjson_SOURCE_DIR}/cJSON.c")
+  target_include_directories(cjson SYSTEM PUBLIC "${cjson_SOURCE_DIR}")

-    initialize_submodule(fastjson)
-    add_library(competition-fastjson INTERFACE)
-    target_include_directories(competition-fastjson INTERFACE fastjson/src fastjson/include)
+  import_dependency(fastjson mikeando/fastjson 485f994)
+  add_library(fastjson STATIC
+          "${fastjson_SOURCE_DIR}/src/fastjson.cpp"
+          "${fastjson_SOURCE_DIR}/src/fastjson2.cpp"
+          "${fastjson_SOURCE_DIR}/src/fastjson_dom.cpp")
+  target_include_directories(fastjson SYSTEM PUBLIC
+          "${fastjson_SOURCE_DIR}/include")

-    initialize_submodule(gason)
-    add_library(competition-gason INTERFACE)
-    target_include_directories(competition-gason INTERFACE gason/src)
+  import_dependency(gason vivkin/gason 7aee524)
+  add_library(gason STATIC "${gason_SOURCE_DIR}/src/gason.cpp")
+  target_include_directories(gason SYSTEM PUBLIC "${gason_SOURCE_DIR}/src")

-    initialize_submodule(jsmn)
-    add_library(competition-jsmn INTERFACE)
-    target_include_directories(competition-jsmn INTERFACE jsmn)
+  import_dependency(jsmn zserge/jsmn 18e9fe4)
+  add_library(jsmn STATIC "${jsmn_SOURCE_DIR}/jsmn.c")
+  target_include_directories(jsmn SYSTEM PUBLIC "${jsmn_SOURCE_DIR}")

-    initialize_submodule(json)
-    add_library(competition-json INTERFACE)
-    target_include_directories(competition-json INTERFACE json/single_include)
+  message(STATUS "Importing json (nlohmann/json@v3.9.1)")
+  set(nlohmann_json_SOURCE_DIR "${dep_root}/json")
+  if(NOT EXISTS "${nlohmann_json_SOURCE_DIR}")
+    file(DOWNLOAD
+            "https://github.com/nlohmann/json/releases/download/v3.9.1/json.hpp"
+            "${nlohmann_json_SOURCE_DIR}/nlohmann/json.hpp")
+  endif()
+  add_library(nlohmann_json INTERFACE)
+  target_include_directories(nlohmann_json SYSTEM INTERFACE "${nlohmann_json_SOURCE_DIR}")

-    initialize_submodule(json11)
-    add_library(competition-json11 INTERFACE)
-    target_include_directories(competition-json11 INTERFACE json11)
+  import_dependency(json11 dropbox/json11 ec4e452)
+  add_library(json11 STATIC "${json11_SOURCE_DIR}/json11.cpp")
+  target_include_directories(json11 SYSTEM PUBLIC "${json11_SOURCE_DIR}")

-    add_library(competition-jsoncppdist INTERFACE)
-    target_include_directories(competition-jsoncppdist INTERFACE jsoncppdist)
+  set(jsoncpp_SOURCE_DIR "${simdjson_SOURCE_DIR}/dependencies/jsoncppdist")
+  add_library(jsoncpp STATIC "${jsoncpp_SOURCE_DIR}/jsoncpp.cpp")
+  target_include_directories(jsoncpp SYSTEM PUBLIC "${jsoncpp_SOURCE_DIR}")

-    initialize_submodule(rapidjson)
-    add_library(competition-rapidjson INTERFACE)
-    target_include_directories(competition-rapidjson INTERFACE rapidjson/include)
+  import_dependency(rapidjson Tencent/rapidjson b32cd94)
+  add_library(rapidjson INTERFACE)
+  target_compile_definitions(rapidjson INTERFACE RAPIDJSON_HAS_STDSTRING)
+  target_include_directories(rapidjson SYSTEM INTERFACE
+          "${rapidjson_SOURCE_DIR}/include")

-    initialize_submodule(sajson)
-    add_library(competition-sajson INTERFACE)
-    target_include_directories(competition-sajson INTERFACE sajson/include)
+  import_dependency(sajson chadaustin/sajson 2dcfd35)
+  add_library(sajson INTERFACE)
+  target_compile_definitions(sajson INTERFACE SAJSON_UNSORTED_OBJECT_KEYS)
+  target_include_directories(sajson SYSTEM INTERFACE
+          "${sajson_SOURCE_DIR}/include")

-    initialize_submodule(ujson4c)
-    add_library(competition-ujson4c ujson4c/src/ujdecode.c)
-    target_include_directories(competition-ujson4c PUBLIC ujson4c/3rdparty ujson4c/src)
+  import_dependency(ujson4c esnme/ujson4c e14f3fd)
+  add_library(ujson4c STATIC
+          "${ujson4c_SOURCE_DIR}/src/ujdecode.c"
+          "${ujson4c_SOURCE_DIR}/3rdparty/ultrajsondec.c")
+  target_include_directories(ujson4c SYSTEM PUBLIC
+          "${ujson4c_SOURCE_DIR}/src"
+          "${ujson4c_SOURCE_DIR}/3rdparty")

-    add_library(competition-core INTERFACE)
-    target_link_libraries(competition-core INTERFACE competition-json competition-rapidjson competition-sajson competition-cJSON competition-jsmn)
+  import_dependency(yyjson ibireme/yyjson aa33ec5)
+  add_library(yyjson STATIC "${yyjson_SOURCE_DIR}/src/yyjson.c")
+  target_include_directories(yyjson SYSTEM PUBLIC "${yyjson_SOURCE_DIR}/src")

-    add_library(competition-all INTERFACE)
-    target_link_libraries(competition-all INTERFACE competition-core competition-jsoncppdist competition-json11 competition-fastjson competition-gason competition-ujson4c)
+  add_library(competition-core INTERFACE)
+  target_link_libraries(competition-core INTERFACE nlohmann_json rapidjson sajson cjson jsmn yyjson)
+  if(USE_BOOST_JSON)
+     target_compile_definitions(boostjson INTERFACE HAS_BOOST_JSON)
+     target_link_libraries(competition-core INTERFACE boostjson)
  endif()

-  initialize_submodule(cxxopts)
-  message(STATUS "We acquired cxxopts and we are adding it as a library and target.")
-  add_library(cxxopts INTERFACE)
-  target_include_directories(cxxopts INTERFACE cxxopts/include)
-else()
-  message(STATUS "Git is unavailable.")
-  if(SIMDJSON_COMPETITION)
-    message (STATUS "'SIMDJSON_COMPETITION' is requested, but we cannot download the  remote repositories." )
-  endif()
-  if(SIMDJSON_GOOGLE_BENCHMARKS)
-    message (STATUS "'SIMDJSON_GOOGLE_BENCHMARKS' is requested, but we cannot download the remote repositories." )
-  endif()
-endif()
+  add_library(competition-all INTERFACE)
+  target_link_libraries(competition-all INTERFACE competition-core jsoncpp json11 fastjson gason ujson4c)
+endfunction()
+
+if(SIMDJSON_COMPETITION)
+  competition_scope_()
+endif()
+
+set_off(CXXOPTS_BUILD_EXAMPLES)
+set_off(CXXOPTS_BUILD_TESTS)
+set_off(CXXOPTS_ENABLE_INSTALL)
+
+import_dependency(cxxopts jarro2783/cxxopts 794c975)
+add_dependency(cxxopts)
@@ -0,0 +1,48 @@
+set(dep_root "${simdjson_SOURCE_DIR}/dependencies/.cache")
+if(DEFINED ENV{simdjson_DEPENDENCY_CACHE_DIR})
+  set(dep_root "$ENV{simdjson_DEPENDENCY_CACHE_DIR}")
+endif()
+
+function(import_dependency NAME GITHUB_REPO COMMIT)
+  message(STATUS "Importing ${NAME} (${GITHUB_REPO}@${COMMIT})")
+  set(target "${dep_root}/${NAME}")
+
+  # If the folder exists in the cache, then we assume that everything is as
+  # should be and do nothing
+  if(EXISTS "${target}")
+    set("${NAME}_SOURCE_DIR" "${target}" PARENT_SCOPE)
+    return()
+  endif()
+
+  set(zip_url "https://github.com/${GITHUB_REPO}/archive/${COMMIT}.zip")
+  set(archive "${dep_root}/archive.zip")
+  set(dest "${dep_root}/_extract")
+
+  file(DOWNLOAD "${zip_url}" "${archive}")
+  file(MAKE_DIRECTORY "${dest}")
+  execute_process(
+          WORKING_DIRECTORY "${dest}"
+          COMMAND "${CMAKE_COMMAND}" -E tar xf "${archive}")
+  file(REMOVE "${archive}")
+
+  # GitHub archives only ever have one folder component at the root, so this
+  # will always match that single folder
+  file(GLOB dir LIST_DIRECTORIES YES "${dest}/*")
+
+  file(RENAME "${dir}" "${target}")
+
+  set("${NAME}_SOURCE_DIR" "${target}" PARENT_SCOPE)
+endfunction()
+
+# Delegates to the dependency
+macro(add_dependency NAME)
+  if(NOT DEFINED "${NAME}_SOURCE_DIR")
+    message(FATAL_ERROR "Missing ${NAME}_SOURCE_DIR variable")
+  endif()
+
+  add_subdirectory("${${NAME}_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/${NAME}")
+endmacro()
+
+function(set_off NAME)
+  set("${NAME}" OFF CACHE INTERNAL "")
+endfunction()
@@ -7,28 +7,28 @@
 // //////////////////////////////////////////////////////////////////////

 /*
-The JsonCpp library's source code, including accompanying documentation, 
+The JsonCpp library's source code, including accompanying documentation,
 tests and demonstration applications, are licensed under the following
 conditions...

-Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all 
-jurisdictions which recognize such a disclaimer. In such jurisdictions, 
+Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all
+jurisdictions which recognize such a disclaimer. In such jurisdictions,
 this software is released into the Public Domain.

 In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
 2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and
 The JsonCpp Authors, and is released under the terms of the MIT License (see below).

-In jurisdictions which recognize Public Domain property, the user of this 
-software may choose to accept it either as 1) Public Domain, 2) under the 
-conditions of the MIT License (see below), or 3) under the terms of dual 
+In jurisdictions which recognize Public Domain property, the user of this
+software may choose to accept it either as 1) Public Domain, 2) under the
+conditions of the MIT License (see below), or 3) under the terms of dual
 Public Domain/MIT License conditions described here, as they choose.

 The MIT License is about as close to Public Domain as a license can get, and is
 described in clear, concise terms at:

   http://en.wikipedia.org/wiki/MIT_License
-   
+
 The full text of the MIT License follows:

 ========================================================================
@@ -6,28 +6,28 @@
 // //////////////////////////////////////////////////////////////////////

 /*
-The JsonCpp library's source code, including accompanying documentation, 
+The JsonCpp library's source code, including accompanying documentation,
 tests and demonstration applications, are licensed under the following
 conditions...

-Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all 
-jurisdictions which recognize such a disclaimer. In such jurisdictions, 
+Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all
+jurisdictions which recognize such a disclaimer. In such jurisdictions,
 this software is released into the Public Domain.

 In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
 2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and
 The JsonCpp Authors, and is released under the terms of the MIT License (see below).

-In jurisdictions which recognize Public Domain property, the user of this 
-software may choose to accept it either as 1) Public Domain, 2) under the 
-conditions of the MIT License (see below), or 3) under the terms of dual 
+In jurisdictions which recognize Public Domain property, the user of this
+software may choose to accept it either as 1) Public Domain, 2) under the
+conditions of the MIT License (see below), or 3) under the terms of dual
 Public Domain/MIT License conditions described here, as they choose.

 The MIT License is about as close to Public Domain as a license can get, and is
 described in clear, concise terms at:

   http://en.wikipedia.org/wiki/MIT_License
-   
+
 The full text of the MIT License follows:

 ========================================================================
@@ -6,28 +6,28 @@
 // //////////////////////////////////////////////////////////////////////

 /*
-The JsonCpp library's source code, including accompanying documentation, 
+The JsonCpp library's source code, including accompanying documentation,
 tests and demonstration applications, are licensed under the following
 conditions...

-Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all 
-jurisdictions which recognize such a disclaimer. In such jurisdictions, 
+Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all
+jurisdictions which recognize such a disclaimer. In such jurisdictions,
 this software is released into the Public Domain.

 In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
 2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and
 The JsonCpp Authors, and is released under the terms of the MIT License (see below).

-In jurisdictions which recognize Public Domain property, the user of this 
-software may choose to accept it either as 1) Public Domain, 2) under the 
-conditions of the MIT License (see below), or 3) under the terms of dual 
+In jurisdictions which recognize Public Domain property, the user of this
+software may choose to accept it either as 1) Public Domain, 2) under the
+conditions of the MIT License (see below), or 3) under the terms of dual
 Public Domain/MIT License conditions described here, as they choose.

 The MIT License is about as close to Public Domain as a license can get, and is
 described in clear, concise terms at:

   http://en.wikipedia.org/wiki/MIT_License
-   
+
 The full text of the MIT License follows:

 ========================================================================
@@ -25,7 +25,7 @@ An overview of what you need to know to use simdjson, with examples.
 Requirements
 ------------------

- A recent compiler (LLVM clang6 or better, GNU GCC 7.4 or better) on a 64-bit (ARM or x64 Intel/AMD) POSIX systems such as macOS, freeBSD or Linux. We require that the compiler supports the C++11 standard or better.
+- A recent compiler (LLVM clang6 or better, GNU GCC 7.4 or better) on a 64-bit (PPC, ARM or x64 Intel/AMD) POSIX systems such as macOS, freeBSD or Linux. We require that the compiler supports the C++11 standard or better.
 - Visual Studio 2017 or better under 64-bit Windows. Users should target a 64-bit build (x64) instead of a 32-bit build (x86). We support the LLVM clang compiler under Visual Studio (clangcl) as well as as the regular Visual Studio compiler. We also support MinGW 64-bit under Windows.

 Including simdjson
@@ -75,7 +75,7 @@ set(SIMDJSON_BUILD_STATIC ON CACHE INTERNAL "")
 FetchContent_MakeAvailable(simdjson)
 ```

-You should replace `GIT_TAG  v0.5.0` by the version you need. If you omit `GIT_TAG  v0.5.0`, you will work from the main branch of simdjson: we recommend that if you are working on production code, 
+You should replace `GIT_TAG  v0.5.0` by the version you need. If you omit `GIT_TAG  v0.5.0`, you will work from the main branch of simdjson: we recommend that if you are working on production code,

 Elsewhere in your project, you can  declare dependencies on simdjson with lines such as these:

@@ -108,15 +108,21 @@ SIMDJSON_PADDING bytes at the end) and calling `parse()`:

 ```c++
 dom::parser parser;
-dom::element doc = parser.parse("[1,2,3]"_padded); // parse a string
+dom::element doc = parser.parse("[1,2,3]"_padded); // parse a string, the _padded suffix creates a simdjson::padded_string instance
 ```

 The parsed document resulting from the `parser.load` and `parser.parse` calls depends on the `parser` instance. Thus the `parser` instance must remain in scope. Furthermore, you must have at most one parsed document in play per `parser` instance.
+You cannot copy a `parser` instance, you may only move it.
+
+If you need to keep a document around long term, you can keep or move the parser instance. Note that moving a parser instance, or keeping one in a movable data structure like vector or map, can cause any outstanding `element`, `object` or `array` instances to be invalidated. If you need to store a parser in a movable data structure, you should use a `std::unique_ptr` to avoid this invalidation(e.g., `std::unique_ptr<dom::parser> parser(new dom::parser{})`).

 During the`load` or `parse` calls, neither the input file nor the input string are ever modified. After calling `load` or `parse`, the source (either a file or a string) can be safely discarded. All of the JSON data is stored in the `parser` instance.  The parsed document is also immutable in simdjson: you do not modify it by accessing it.

 For best performance, a `parser` instance should be reused over several files: otherwise you will needlessly reallocate memory, an expensive process. It is also possible to avoid entirely memory allocations during parsing when using simdjson. [See our performance notes for details](performance.md).

+If you need a lower-level interface, you may call the function `parser.parse(const char * p, size_t l)` on a pointer `p` while specifying the
+length of your input `l` in bytes. To see how to get the very best performance from a low-level approach, you way want to read our [performance notes](https://github.com/simdjson/simdjson/blob/master/doc/performance.md#padding-and-temporary-copies) on this topic (see the Padding and Temporary Copies section).
+

 Using the Parsed JSON
 ---------------------
@@ -126,7 +132,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
 * **Extracting Values (with exceptions):** You can cast a JSON element to a native type: `double(element)` or
  `double x = json_element`. This works for double, uint64_t, int64_t, bool,
  dom::object and dom::array. An exception is thrown if the cast is not possible.
-* **Extracting Values (without expceptions):** You can use a variant usage of `get()` with error codes to avoid exceptions. You first declare the variable of the appropriate type (`double`, `uint64_t`, `int64_t`, `bool`,
+* **Extracting Values (without exceptions):** You can use a variant usage of `get()` with error codes to avoid exceptions. You first declare the variable of the appropriate type (`double`, `uint64_t`, `int64_t`, `bool`,
  `dom::object` and `dom::array`) and pass it by reference to `get()` which gives you back an error code: e.g.,
  ```c++
  simdjson::error_code error;
@@ -149,10 +155,11 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
 * **Array and Object size** Given an array or an object, you can get its size (number of elements or keys)
  with the `size()` method.
 * **Checking an Element Type:** You can check an element's type with `element.type()`. It
-  returns an `element_type`.
+  returns an `element_type` with values such as `simdjson::dom::element_type::ARRAY`, `simdjson::dom::element_type::OBJECT`, `simdjson::dom::element_type::INT64`,  `simdjson::dom::element_type::UINT64`,`simdjson::dom::element_type::DOUBLE`, `simdjson::dom::element_type::BOOL` or, `simdjson::dom::element_type::NULL_VALUE`.
+* **Output to streams and strings:** Given a document or an element (or node) out of a JSON document, you can output a minified string version using the C++ stream idiom (`out << element`). You can also request the construction of a minified string version (`simdjson::minify(element)`).


-Here are some examples of all of the above:
+The following code illustrates all of the above:

 ```c++
 auto cars_json = R"( [
@@ -233,7 +240,7 @@ available, we define the macro `SIMDJSON_HAS_STRING_VIEW`.

 When we detect that it is unavailable,
 we use [string-view-lite](https://github.com/martinmoene/string-view-lite) as a
-substitute. In such cases, we use the type alias `using string_view = nonstd::string_view;` to  
+substitute. In such cases, we use the type alias `using string_view = nonstd::string_view;` to
 offer the same API, irrespective of the compiler and standard library. The macro
 `SIMDJSON_HAS_STRING_VIEW` will be *undefined* to indicate that we emulate `string_view`.

@@ -271,16 +278,15 @@ for (dom::key_value_pair field : object) {
 Minifying JSON strings without parsing
 ----------------------

-In some cases, you may have valid JSON strings that you do not wish to parse but that you wish to minify. That is, you wish to remove all unnecessary spaces. We have a fast function for this purpose (`minify`). This function does not validate your content, and it does not parse it. Instead, it assumes that your string is valid UTF-8. It is much faster than parsing the string and re-serializing it in minified form. Usage is relatively simple. You must pass an input pointer with a length parameter, as well as an output pointer and an output length parameter (by reference). The output length parameter is not read, but written to. The output pointer should point to a valid memory region that is slightly overallocated (by `simdjson::SIMDJSON_PADDING`) compared to the original string length. The input pointer and input length are read, but not written to.
+In some cases, you may have valid JSON strings that you do not wish to parse but that you wish to minify. That is, you wish to remove all unnecessary spaces. We have a fast function for this purpose (`simdjson::minify(const char * input, size_t length, const char * output, size_t& new_length)`). This function does not validate your content, and it does not parse it.  It is much faster than parsing the string and re-serializing it in minified form (`simdjson::minify(parser.parse())`). Usage is relatively simple. You must pass an input pointer with a length parameter, as well as an output pointer and an output length parameter (by reference). The output length parameter is not read, but written to. The output pointer should point to a valid memory region that is as large as the original string length. The input pointer and input length are read, but not written to.

 ```C++
  // Starts with a valid JSON document as a string.
  // It does not have to be null-terminated.
  const char * some_string = "[ 1, 2, 3, 4] ";
-  size_t length = strlen(some_string);
-  // Create a buffer to receive the minified string. Make sure that there is enough room,
-  // including some padding (simdjson::SIMDJSON_PADDING).
-  std::unique_ptr<char[]> buffer{new(std::nothrow) char[length + simdjson::SIMDJSON_PADDING]};
+  size_t length = std::strlen(some_string);
+  // Create a buffer to receive the minified string. Make sure that there is enough room (length bytes).
+  std::unique_ptr<char[]> buffer{new char[length]};
  size_t new_length{}; // It will receive the minified length.
  auto error = simdjson::minify(some_string, length, buffer.get(), new_length);
  // The buffer variable now has "[1,2,3,4]" and new_length has value 9.
@@ -296,7 +302,7 @@ The simdjson library has fast functions to validate UTF-8 strings. They are many

 ```C++
  const char * some_string = "[ 1, 2, 3, 4] ";
-  size_t length = strlen(some_string);
+  size_t length = std::strlen(some_string);
  bool is_ok = simdjson::validate_utf8(some_string, length);
 ```

@@ -326,10 +332,10 @@ index allows you to select the indexed node. Within objects, the string value of
 select the value. If your keys contain the characters '/' or '~', they must be escaped as '~1' and
 '~0' respectively. An empty JSON Path refers to the whole document.

-We also extend the JSON Pointer support to include *relative* paths.  
+We also extend the JSON Pointer support to include *relative* paths.
 You can apply a JSON path to any node and the path gets interpreted relatively, as if the currrent node were a whole JSON document.

-Consider the following example: 
+Consider the following example:

 ```c++
 auto cars_json = R"( [
@@ -367,14 +373,31 @@ When you use the code this way, it is your responsibility to check for error bef
 result: if there is an error, the result value will not be valid and using it will caused undefined
 behavior.

-We can write a "quick start" example where we attempt to parse a file and access some data, without triggering exceptions:
+We can write a "quick start" example where we attempt to parse the following JSON file and access some data, without triggering exceptions:
+```JavaScript
+{
+  "statuses": [
+    {
+      "id": 505874924095815700
+    },
+    {
+      "id": 505874922023837700
+    }
+  ],
+  "search_metadata": {
+    "count": 100
+  }
+}
+```
+
+Our program loads the file, selects value corresponding to key "search_metadata" which expected to be an object, and then
+it selects the key "count" within that object.

 ```C++
 #include "simdjson.h"

 int main(void) {
  simdjson::dom::parser parser;
-
  simdjson::dom::element tweets;
  auto error = parser.load("twitter.json").get(tweets);
  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
@@ -388,6 +411,31 @@ int main(void) {
 }
 ```

+The following is a similar example where one wants to get the id of the first tweet without
+triggering exceptions. To do this, we use `["statuses"].at(0)["id"]`. We break that expression down:
+
+- Get the list of tweets (the `"statuses"` key of the document) using `["statuses"]`). The result is expected to be an array.
+- Get the first tweet using `.at(0)`. The result is expected to be an object.
+- Get the id of the tweet using ["id"]. We expect the value to be a non-negative integer.
+
+Observe how we use the `at` method when querying an index into an array, and not the bracket operator.
+
+```C++
+#include "simdjson.h"
+
+int main(void) {
+  simdjson::dom::parser parser;
+  simdjson::dom::element tweets;
+  auto error = parser.load("twitter.json").get(tweets);
+  if(error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+  uint64_t identifier;
+  error = tweets["statuses"].at(0)["id"].get(identifier);
+  if(error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+  std::cout << identifier << std::endl;
+  return EXIT_SUCCESS;
+}
+```
+
 ### Error Handling Example

 This is how the example in "Using the Parsed JSON" could be written using only error code checking:
@@ -519,6 +567,21 @@ dom::element doc = parser.parse(json); // Throws an exception if there was an er
 When used this way, a `simdjson_error` exception will be thrown if an error occurs, preventing the
 program from continuing if there was an error.

+
+If one is willing to trigger exceptions, it is possible to write simpler code:
+
+```C++
+#include "simdjson.h"
+
+int main(void) {
+  simdjson::dom::parser parser;
+  simdjson::dom::element tweets = parser.load("twitter.json");
+  std::cout << "ID: " << tweets["statuses"].at(0)["id"] << std::endl;
+  return EXIT_SUCCESS;
+}
+```
+
+
 Tree Walking and JSON Element Types
 -----------------------------------

@@ -582,7 +645,7 @@ format. If your JSON documents all contain arrays or objects, we even support di
 concatenation without whitespace. The concatenated file has no size restrictions (including larger
 than 4GB), though each individual document must be no larger than 4 GB.

-Here is a simple example, given "x.json" with this content:
+Here is a simple example, given `x.json` with this content:

 ```json
 { "foo": 1 }
@@ -592,17 +655,42 @@ Here is a simple example, given "x.json" with this content:

 ```c++
 dom::parser parser;
-dom::document_stream docs = parser.load_many(filename);
+dom::document_stream docs = parser.load_many("x.json");
 for (dom::element doc : docs) {
  cout << doc["foo"] << endl;
 }
 // Prints 1 2 3
 ```

-In-memory ndjson strings can be parsed as well, with `parser.parse_many(string)`.
+In-memory ndjson strings can be parsed as well, with `parser.parse_many(string)`:
+
+
+```c++
+dom::parser parser;
+  auto json = R"({ "foo": 1 }
+{ "foo": 2 }
+{ "foo": 3 })"_padded;
+dom::document_stream docs = parser.parse_many(json);
+for (dom::element doc : docs) {
+  cout << doc["foo"] << endl;
+}
+// Prints 1 2 3
+```
+
+
+Unlike `parser.parse`, both `parser.load_many(filename)` and `parser.parse_many(string)` may parse
+"on demand" (lazily). That is, no parsing may have been done before you enter the loop
+`for (dom::element doc : docs) {` and you should expect the parser to only ever fully parse one JSON
+document at a time.
+
+1. When calling `parser.load_many(filename)`, the file's content is loaded up in a memory buffer owned by the `parser`'s instance. Thus the file can be safely deleted after calling `parser.load_many(filename)` as the parser instance owns all of the data.
+2. When calling  `parser.parse_many(string)`, no copy is made of the provided string input. The provided memory buffer may be accessed each time a JSON document is parsed.  Calling `parser.parse_many(string)` on a  temporary string buffer (e.g., `docs = parser.parse_many("[1,2,3]"_padded)`) is unsafe (and will not compile) because the  `document_stream` instance needs access to the buffer to return the JSON documents. In constrast, calling `doc = parser.parse("[1,2,3]"_padded)` is safe because `parser.parse` eagerly parses the input.
+

 Both `load_many` and `parse_many` take an optional parameter `size_t batch_size` which defines the window processing size. It is set by default to a large value (`1000000` corresponding to 1 MB). None of your JSON documents should exceed this window size, or else you will get  the error `simdjson::CAPACITY`. You cannot set this window size larger than 4 GB: you will get  the error `simdjson::CAPACITY`. The smaller the window size is, the less memory the function will use. Setting the window size too small (e.g., less than 100 kB) may also impact performance negatively. Leaving it to 1 MB is expected to be a good choice, unless you have some larger documents.

+If your documents are large (e.g., larger than a megabyte), then the `load_many` and `parse_many` functions are maybe ill-suited. They are really meant to support reading efficiently streams of relatively small documents (e.g., a few kilobytes each). If you have larger documents, you should use other functions like `parse`.
+
 See [parse_many.md](parse_many.md) for detailed information and design.

 Thread Safety
@@ -629,8 +717,8 @@ The simdjson library is fully compliant with  the [RFC 8259](https://www.tbray.o
 - The only insignificant whitespace characters allowed are the space, the horizontal tab, the line feed and the carriage return. In particular, a JSON document may not contain an unespaced null character.
 - A single string or a single number is considered to be a valid JSON document.
 - We fully validate the numbers according to the JSON specification. For example,  the string `01` is not valid JSON document since the specification states that *leading zeros are not allowed*.
- The specification allows implementations to set limits on the range and precision of numbers accepted.  We support 64-bit floating-point numbers as well as integer values. 
-  - We parse integers and floating-point numbers as separate types which allows us to support all signed (two complement's) 64-bit integers, like a Java `long` or a C/C++ `long long` and all 64-bit unsigned integers. When we cannot represent exactly an integer as a signed or unsigned 64-bit value, we reject the JSON document. 
+- The specification allows implementations to set limits on the range and precision of numbers accepted.  We support 64-bit floating-point numbers as well as integer values.
+  - We parse integers and floating-point numbers as separate types which allows us to support all signed (two complement's) 64-bit integers, like a Java `long` or a C/C++ `long long` and all 64-bit unsigned integers. When we cannot represent exactly an integer as a signed or unsigned 64-bit value, we reject the JSON document.
  - We support the full range of 64-bit floating-point numbers (binary64). The values range from `std::numeric_limits<double>::lowest()`  to `std::numeric_limits<double>::max()`, so from -1.7976e308 all the way to 1.7975e308. Extreme values (less or equal to -1e308, greater or equal to 1e308) are rejected: we refuse to parse the input document. Numbers are parsed with with a perfect accuracy (ULP 0): the nearest floating-point value is chosen, rounding to even when needed. If you serialized your floating-point numbers with 17 significant digits in a standard compliant manner, the simdjson library is guaranteed to recovere the example same numbers, exactly.
 - The specification states that JSON text exchanged between systems that are not part of a closed ecosystem MUST be encoded using UTF-8. The simdjson library does full UTF-8 validation as part of the parsing. The specification states that implementations MUST NOT add a byte order mark: the simdjson library rejects documents starting with a  byte order mark.
 - The simdjson library validates string content for unescaped characters. Unescaped line breaks and tabs in strings are not allowed.
@@ -7,7 +7,7 @@ An overview of what you need to know to use simdjson, with examples.
 Requirements
 ------------------

- A recent compiler (LLVM clang6 or better, GNU GCC 7 or better) on a 64-bit (ARM or x64 Intel/AMD) POSIX systems such as macOS, freeBSD or Linux. We require that the compiler supports the C++11 standard or better.
+- A recent compiler (LLVM clang6 or better, GNU GCC 7 or better) on a 64-bit (PPC, ARM or x64 Intel/AMD) POSIX systems such as macOS, freeBSD or Linux. We require that the compiler supports the C++11 standard or better.
 - Visual Studio 2017 or better under 64-bit Windows. Users should target a 64-bit build (x64) instead of a 32-bit build (x86). We support the LLVM clang compiler under Visual Studio (clangcl) as well as as the regular Visual Studio compiler.

 Including simdjson
@@ -47,7 +47,7 @@ include(FetchContent)
 FetchContent_Declare(
  simdjson
  GIT_REPOSITORY https://github.com/simdjson/simdjson.git
-  GIT_TAG  v0.4.7
+  GIT_TAG  v0.6.1
  GIT_SHALLOW TRUE)

 set(SIMDJSON_JUST_LIBRARY ON CACHE INTERNAL "")
@@ -56,7 +56,7 @@ set(SIMDJSON_BUILD_STATIC ON CACHE INTERNAL "")
 FetchContent_MakeAvailable(simdjson)
 ```

-You should replace `GIT_TAG  v0.5.0` by the version you need. If you omit `GIT_TAG  v0.5.0`, you will work from the main branch of simdjson: we recommend that if you are working on production code, 
+You should replace `GIT_TAG  v0.6.1` by the version you need. If you omit `GIT_TAG  v0.6.1`, you will work from the main branch of simdjson: we recommend that if you are working on production code,

 Elsewhere in your project, you can  declare dependencies on simdjson with lines such as these:

@@ -89,16 +89,22 @@ SIMDJSON_PADDING bytes at the end) and calling `parse()`:

 ```
 dom::parser parser;
-dom::element doc = parser.parse("[1,2,3]"_padded); // parse a string
+dom::element doc = parser.parse("[1,2,3]"_padded); // parse a string, the _padded suffix creates a simdjson::padded_string instance
 ```

 The parsed document resulting from the `parser.load` and `parser.parse` calls depends on the `parser` instance. Thus the `parser` instance must remain in scope. Furthermore, you must have at most one parsed document in play per `parser` instance.
+You cannot copy a `parser` instance, you may only move it.
+
+If you need to keep a document around long term, you can keep or move the parser instance. Note that moving a parser instance, or keeping one in a movable data structure like vector or map, can cause any outstanding `element`, `object` or `array` instances to be invalidated. If you need to store a parser in a movable data structure, you should use a `std::unique_ptr` to avoid this invalidation(e.g., `std::unique_ptr<dom::parser> parser(new dom::parser{})`).

 During the`load` or `parse` calls, neither the input file nor the input string are ever modified. After calling `load` or `parse`, the source (either a file or a string) can be safely discarded. All of the JSON data is stored in the `parser` instance.  The parsed document is also immutable in simdjson: you do not modify it by accessing it.

-For best performance, a `parser` instance should be reused over several files: otherwise you will needlessly reallocate memory, an expensive process. It is also possible to avoid entirely memory allocations during parsing when using simdjson. 
+For best performance, a `parser` instance should be reused over several files: otherwise you will needlessly reallocate memory, an expensive process. It is also possible to avoid entirely memory allocations during parsing when using simdjson.


+If you need a lower-level interface, you may call the function `parser.parse(const char * p, size_t l)` on a pointer `p` while specifying the
+length of your input `l` in bytes. To see how to get the very best performance from a low-level approach, you way want to read our [performance notes](https://github.com/simdjson/simdjson/blob/master/doc/performance.md#padding-and-temporary-copies) on this topic (see the Padding and Temporary Copies section).
+
 Using the Parsed JSON
 ---------------------

@@ -107,7 +113,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
 * **Extracting Values (with exceptions):** You can cast a JSON element to a native type: `double(element)` or
  `double x = json_element`. This works for double, uint64_t, int64_t, bool,
  dom::object and dom::array. An exception is thrown if the cast is not possible.
-* **Extracting Values (without expceptions):** You can use a variant usage of `get()` with error codes to avoid exceptions. You first declare the variable of the appropriate type (`double`, `uint64_t`, `int64_t`, `bool`,
+* **Extracting Values (without exceptions):** You can use a variant usage of `get()` with error codes to avoid exceptions. You first declare the variable of the appropriate type (`double`, `uint64_t`, `int64_t`, `bool`,
  `dom::object` and `dom::array`) and pass it by reference to `get()` which gives you back an error code: e.g.,
  ```
  simdjson::error_code error;
@@ -130,10 +136,11 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
 * **Array and Object size** Given an array or an object, you can get its size (number of elements or keys)
  with the `size()` method.
 * **Checking an Element Type:** You can check an element's type with `element.type()`. It
-  returns an `element_type`.
+  returns an `element_type` with values such as `simdjson::dom::element_type::ARRAY`, `simdjson::dom::element_type::OBJECT`, `simdjson::dom::element_type::INT64`,  `simdjson::dom::element_type::UINT64`,`simdjson::dom::element_type::DOUBLE`, `simdjson::dom::element_type::BOOL` or, `simdjson::dom::element_type::NULL_VALUE`.
+* **Output to Streams and Strings:** Given a document or an element (or node) out of a JSON document, you can output a minified string version using the C++ stream idiom (`out << element`). You can also request the construction of a minified string version (`simdjson::minify(element)`).


-Here are some examples of all of the above:
+The following code illustrates all of the above:

 ```
 auto cars_json = R"( [
@@ -214,7 +221,7 @@ available, we define the macro `SIMDJSON_HAS_STRING_VIEW`.

 When we detect that it is unavailable,
 we use [string-view-lite](https://github.com/martinmoene/string-view-lite) as a
-substitute. In such cases, we use the type alias `using string_view = nonstd::string_view;` to  
+substitute. In such cases, we use the type alias `using string_view = nonstd::string_view;` to
 offer the same API, irrespective of the compiler and standard library. The macro
 `SIMDJSON_HAS_STRING_VIEW` will be *undefined* to indicate that we emulate `string_view`.

@@ -252,16 +259,16 @@ for (dom::key_value_pair field : object) {
 Minifying JSON strings without parsing
 ----------------------

-In some cases, you may have valid JSON strings that you do not wish to parse but that you wish to minify. That is, you wish to remove all unnecessary spaces. We have a fast function for this purpose (`minify`). This function does not validate your content, and it does not parse it. Instead, it assumes that your string is valid UTF-8. It is much faster than parsing the string and re-serializing it in minified form. Usage is relatively simple. You must pass an input pointer with a length parameter, as well as an output pointer and an output length parameter (by reference). The output length parameter is not read, but written to. The output pointer should point to a valid memory region that is slightly overallocated (by `simdjson::SIMDJSON_PADDING`) compared to the original string length. The input pointer and input length are read, but not written to.
+In some cases, you may have valid JSON strings that you do not wish to parse but that you wish to minify. That is, you wish to remove all unnecessary spaces. We have a fast function for this purpose (`simdjson::minify(const char * input, size_t length, const char * output, size_t& new_length)`). This function does not validate your content, and it does not parse it.  It is much faster than parsing the string and re-serializing it in minified form (`simdjson::minify(parser.parse())`). Usage is relatively simple. You must pass an input pointer with a length parameter, as well as an output pointer and an output length parameter (by reference). The output length parameter is not read, but written to. The output pointer should point to a valid memory region that is as large as the original string length. The input pointer and input length are read, but not written to.
+

 ```
  // Starts with a valid JSON document as a string.
  // It does not have to be null-terminated.
  const char * some_string = "[ 1, 2, 3, 4] ";
-  size_t length = strlen(some_string);
-  // Create a buffer to receive the minified string. Make sure that there is enough room,
-  // including some padding (simdjson::SIMDJSON_PADDING).
-  std::unique_ptr<char[]> buffer{new(std::nothrow) char[length + simdjson::SIMDJSON_PADDING]};
+  size_t length = std::strlen(some_string);
+  // Create a buffer to receive the minified string. Make sure that there is enough room (length bytes).
+  std::unique_ptr<char[]> buffer{new char[length]};
  size_t new_length{}; // It will receive the minified length.
  auto error = simdjson::minify(some_string, length, buffer.get(), new_length);
  // The buffer variable now has "[1,2,3,4]" and new_length has value 9.
@@ -277,7 +284,7 @@ The simdjson library has fast functions to validate UTF-8 strings. They are many

 ```
  const char * some_string = "[ 1, 2, 3, 4] ";
-  size_t length = strlen(some_string);
+  size_t length = std::strlen(some_string);
  bool is_ok = simdjson::validate_utf8(some_string, length);
 ```

@@ -307,10 +314,10 @@ index allows you to select the indexed node. Within objects, the string value of
 select the value. If your keys contain the characters '/' or '~', they must be escaped as '~1' and
 '~0' respectively. An empty JSON Path refers to the whole document.

-We also extend the JSON Pointer support to include *relative* paths.  
+We also extend the JSON Pointer support to include *relative* paths.
 You can apply a JSON path to any node and the path gets interpreted relatively, as if the currrent node were a whole JSON document.

-Consider the following example: 
+Consider the following example:

 ```c++
 auto cars_json = R"( [
@@ -347,14 +354,33 @@ When you use the code this way, it is your responsibility to check for error bef
 result: if there is an error, the result value will not be valid and using it will caused undefined
 behavior.

-We can write a "quick start" example where we attempt to parse a file and access some data, without triggering exceptions:

+
+We can write a "quick start" example where we attempt to parse the following JSON file and access some data, without triggering exceptions:
+```JavaScript
+{
+  "statuses": [
+    {
+      "id": 505874924095815700
+    },
+    {
+      "id": 505874922023837700
+    }
+  ],
+  "search_metadata": {
+    "count": 100
+  }
+}
 ```
+
+Our program loads the file, selects value corresponding to key "search_metadata" which expected to be an object, and then
+it selects the key "count" within that object.
+
+```C++
 #include "simdjson.h"

 int main(void) {
  simdjson::dom::parser parser;
-
  simdjson::dom::element tweets;
  auto error = parser.load("twitter.json").get(tweets);
  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
@@ -368,6 +394,32 @@ int main(void) {
 }
 ```

+
+The following is a similar example where one wants to get the id of the first tweet without
+triggering exceptions. To do this, we use `["statuses"].at(0)["id"]`. We break that expression down:
+
+- Get the list of tweets (the `"statuses"` key of the document) using `["statuses"]`). The result is expected to be an array.
+- Get the first tweet using `.at(0)`. The result is expected to be an object.
+- Get the id of the tweet using ["id"]. We expect the value to be a non-negative integer.
+
+Observe how we use the `at` method when querying an index into an array, and not the bracket operator.
+
+```
+#include "simdjson.h"
+
+int main(void) {
+  simdjson::dom::parser parser;
+  simdjson::dom::element tweets;
+  auto error = parser.load("twitter.json").get(tweets);
+  if(error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+  uint64_t identifier;
+  error = tweets["statuses"].at(0)["id"].get(identifier);
+  if(error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+  std::cout << identifier << std::endl;
+  return EXIT_SUCCESS;
+}
+```
+
 ### Error Handling Example

 This is how the example in "Using the Parsed JSON" could be written using only error code checking:
@@ -499,6 +551,21 @@ dom::element doc = parser.parse(json); // Throws an exception if there was an er
 When used this way, a `simdjson_error` exception will be thrown if an error occurs, preventing the
 program from continuing if there was an error.

+
+
+If one is willing to trigger exceptions, it is possible to write simpler code:
+
+```
+#include "simdjson.h"
+
+int main(void) {
+  simdjson::dom::parser parser;
+  simdjson::dom::element tweets = parser.load("twitter.json");
+  std::cout << "ID: " << tweets["statuses"].at(0)["id"] << std::endl;
+  return EXIT_SUCCESS;
+}
+```
+
 Tree Walking and JSON Element Types
 -----------------------------------

@@ -564,7 +631,7 @@ than 4GB), though each individual document must be no larger than 4 GB.

 Here is a simple example, given "x.json" with this content:

-```json
+```
 { "foo": 1 }
 { "foo": 2 }
 { "foo": 3 }
@@ -572,14 +639,37 @@ Here is a simple example, given "x.json" with this content:

 ```
 dom::parser parser;
-dom::document_stream docs = parser.load_many(filename);
+dom::document_stream docs = parser.load_many("x.json");
 for (dom::element doc : docs) {
  cout << doc["foo"] << endl;
 }
 // Prints 1 2 3
 ```

-In-memory ndjson strings can be parsed as well, with `parser.parse_many(string)`.
+
+In-memory ndjson strings can be parsed as well, with `parser.parse_many(string)`:
+
+
+```
+dom::parser parser;
+  auto json = R"({ "foo": 1 }
+{ "foo": 2 }
+{ "foo": 3 })"_padded;
+dom::document_stream docs = parser.parse_many(json);
+for (dom::element doc : docs) {
+  cout << doc["foo"] << endl;
+}
+// Prints 1 2 3
+```
+
+
+Unlike `parser.parse`, both `parser.load_many(filename)` and `parser.parse_many(string)` may parse
+"on demand" (lazily). That is, no parsing may have been done before you enter the loop
+`for (dom::element doc : docs) {` and you should expect the parser to only ever fully parse one JSON
+document at a time.
+
+1. When calling `parser.load_many(filename)`, the file's content is loaded up in a memory buffer owned by the `parser`'s instance. Thus the file can be safely deleted after calling `parser.load_many(filename)` as the parser instance owns all of the data.
+2. When calling  `parser.parse_many(string)`, no copy is made of the provided string input. The provided memory buffer may be accessed each time a JSON document is parsed.  Calling `parser.parse_many(string)` on a  temporary string buffer (e.g., `docs = parser.parse_many("[1,2,3]"_padded)`) is unsafe  (and will not compile) because the  `document_stream` instance needs access to the buffer to return the JSON documents. In constrast, calling `doc = parser.parse("[1,2,3]"_padded)` is safe because `parser.parse` eagerly parses the input.

 Both `load_many` and `parse_many` take an optional parameter `size_t batch_size` which defines the window processing size. It is set by default to a large value (`1000000` corresponding to 1 MB). None of your JSON documents should exceed this window size, or else you will get  the error `simdjson::CAPACITY`. You cannot set this window size larger than 4 GB: you will get  the error `simdjson::CAPACITY`. The smaller the window size is, the less memory the function will use. Setting the window size too small (e.g., less than 100 kB) may also impact performance negatively. Leaving it to 1 MB is expected to be a good choice, unless you have some larger documents.

@@ -6,6 +6,7 @@ CPU Architecture-Specific Implementations
 * [Inspecting the Detected Implementation](#inspecting-the-detected-implementation)
 * [Querying Available Implementations](#querying-available-implementations)
 * [Manually Selecting the Implementation](#manually-selecting-the-implementation)
+* [Checking that an Implementation can Run on your System](#checking-that-an-implementation-can-run-on-your-system)

 Overview
 --------
@@ -19,20 +20,22 @@ The current implementations are:
 * haswell: AVX2 (2013 Intel Haswell or later)
 * westmere: SSE4.2 (2010 Westmere or later).
 * arm64: 64-bit ARMv8-A NEON
+* ppc64: 64-bit POWER8 and POWER9 with VSX and ALTIVEC extensions. Both big endian and little endian are implemented, depends on the compiler you are using.
 * fallback: A generic implementation that runs on any 64-bit processor.

 In many cases, you don't know where your compiled binary is going to run, so simdjson automatically
 compiles *all* the implementations into the executable. On Intel, it will include 3 implementations
-(haswell, westmere and fallback), and on ARM it will include 2 (arm64 and fallback).
+(haswell, westmere and fallback), on ARM it will include 2 (arm64 and fallback), and on PPC it will include 2 (ppc64 and fallback).

 If you know more about where you're going to run and want to save the space, you can disable any of
 these implementations at compile time with `-DSIMDJSON_IMPLEMENTATION_X=0` (where X is HASWELL,
-WESTMERE, ARM64 and FALLBACK).
+WESTMERE, ARM64, PPC64 and FALLBACK).

 The simdjson library automatically sets header flags for each implementation as it compiles; there
 is no need to set architecture-specific flags yourself (e.g., `-mavx2`, `/AVX2`  or
 `-march=haswell`), and it may even break runtime dispatch and your binaries will fail to run on
-older processors.
+older processors. _Note:_ for POWER9 processors make sure you compile it with `-mcpu=power9` and `-mtune=power9` to
+get maximum performance.

 Runtime CPU Detection
 ---------------------
@@ -70,6 +73,14 @@ And look them up by name:
 ```c++
 cout << simdjson::available_implementations["fallback"]->description() << endl;
 ```
+Though the fallback implementation should always be available, others might be missing. When
+an implementation is not available, the bracket call `simdjson::available_implementations[name]`
+will return the null pointer.
+
+The available implementations have been compiled but may not necessarily be run safely on your system
+see [Checking that an Implementation can Run on your System](#checking-that-an-implementation-can-run-on-your-system).
+
+

 Manually Selecting the Implementation
 -------------------------------------
@@ -81,3 +92,30 @@ can select the CPU architecture yourself:
 // Use the fallback implementation, even though my machine is fast enough for anything
 simdjson::active_implementation = simdjson::available_implementations["fallback"];
 ```
+
+You are responsible for ensuring that the requirements of the selected implementation match your current system.
+Furthermore, you should check that the implementation is available before setting it to `simdjson::active_implementation`
+by comparing it with the null pointer.
+
+```c++
+auto my_implementation = simdjson::available_implementations["haswell"];
+if(! my_implementation) { exit(1); }
+if(! my_implementation->supported_by_runtime_system()) { exit(1); }
+simdjson::active_implementation = my_implementation;
+```
+
+Checking that an Implementation can Run on your System
+-------------------------------------
+
+You should call `supported_by_runtime_system()` to compare the processor's features with the need of the implementation.
+
+```c++
+for (auto implementation : simdjson::available_implementations) {
+  if(implementation->supported_by_runtime_system()) {
+    cout << implementation->name() << ": " << implementation->description() << endl;
+  }
+}
+```
+
+The call to `supported_by_runtime_system()` maybe relatively expensive. Do not call  `supported_by_runtime_system()` each
+time you parse a JSON input (for example). It is meant to be called a handful of times at most in the life of a program.
@@ -0,0 +1,629 @@
+
+A Better Way to Parse Documents?
+====================
+
+Whether we parse JSON or XML, or any other serialized format, there are relatively few common strategies:
+
+- The most established approach is the construction of document-object-model (DOM).
+- Another established approach is a event-based approach (like SAX, SAJ).
+- Another popular approach is the schema-based deserialization model.
+
+We propose an approach that is as easy to use and often as flexible as the DOM approach, yet as fast and
+efficient as the schema-based or event-based approaches. We call this new approach "On Demand". The
+simdjson On Demand API offers a familiar, friendly DOM API and
+provides the performance of just-in-time parsing on top of the simdjson superior performance.
+
+To achieve ease of use, we mimicked the *form* of a traditional DOM API: you can iterate over
+arrays, look up fields in objects, and extract native values like `double`, `uint64_t`, `string` and `bool`.
+
+To achieve performance, we introduced some key limitations that make the DOM API *streaming*:
+array/object iteration cannot be restarted, and fields must be looked up in order, and string/number
+values can only be parsed once. If these limitations are acceptable to you, the On Demand API could
+help you write maintainable applications with a computation efficiency that is difficult to surpass.
+
+A code example illustrates our API from a programmer's point of view:
+
+```c++
+ondemand::parser parser;
+auto doc = parser.iterate(json);
+for (auto tweet : doc["statuses"]) {
+  std::string_view text        = tweet["text"];
+  std::string_view screen_name = tweet["user"]["screen_name"];
+  std::string_view screen_name;
+  {
+        ondemand::object user        = tweet["user"];
+        screen_name                  = user["screen_name"];
+  }
+  uint64_t         retweets    = tweet["retweet_count"];
+  uint64_t         favorites   = tweet["favorite_count"];
+  cout << screen_name << " (" << retweets << " retweets / " << favorites << " favorites): " << text << endl;
+}
+```
+
+Such code would be apply to a JSON document such as the following JSON mimicking a sample result from the Twitter API:
+
+```json
+{
+	"statuses": [{
+			"text": "@aym0566x \n\n名前:前田あゆみ\n第一印象:なんか怖っ！\n今の印象:とりあえずキモい。噛み合わない\n好きなところ:ぶすでキモいとこ😋✨✨\n思い出:んーーー、ありすぎ😊❤️\nLINE交換できる？:あぁ……ごめん✋\nトプ画をみて:照れますがな😘✨\n一言:お前は一生もんのダチ💖",
+			"user": {
+				"name": "AYUMI",
+				"screen_name": "ayuu0123",
+				"followers_count": 262,
+				"friends_count": 252
+			},
+			"retweet_count": 0,
+			"favorite_count": 0
+		},
+		{
+			"text": "RT @KATANA77: えっそれは・・・（一同） http://t.co/PkCJAcSuYK",
+			"user": {
+				"name": "RT&ファボ魔のむっつんさっm",
+				"screen_name": "yuttari1998",
+				"followers_count": 95,
+				"friends_count": 158
+			},
+			"retweet_count": 82,
+			"favorite_count": 42
+		}
+	]
+}
+```
+
+This streaming approach means that unused fields and values are not parsed or
+converted, thus saving space and time. In our example, the `"name"`, `"followers_count"`,
+and `"friends_count"` keys and matching values are skipped.
+
+Further, the On Demand API does not parse a value *at all* until you try to convert it (e.g., to `double`,
+`int`, `string`, or `bool`). In our example, when accessing the key-value pair `"retweet_count": 82`, the parser
+may not convert the pair of characters `82` to the binary integer 82. Because the programmer specifies the data
+type, we avoid branch mispredictions related to data type determination and improve the performance.
+
+
+We expect users of an On Demand API to work in terms of a JSON dialect, which is a set of expectations and
+specifications that come in addition to the [JSON specification](https://www.rfc-editor.org/rfc/rfc8259.txt).
+The On Demand approach is designed around several principles:
+
+* **Streaming (\*):** It avoids preparsing values, keeping the memory usage and the latency down.
+* **Forward-Only:** To prevent reiteration of the same values and to keep the number of variables down (literally), only a single index is maintained and everything uses it (even if you have nested for loops). This means when you are going through an array of arrays, for example, that the inner array loop will advance the index to the next comma, and the array can just pick it up and look at it.
+* **Natural Iteration:** A JSON array or object can be iterated with a normal C++ for loop. Nested arrays and objects are supported by nested for loops.
+* **Use-Specific Parsing:** Parsing is always specific to the type required by the programmer. For example, if the programmer asks for an unsigned integer, we just start parsing digits. If there were no digits, we toss an error. There are even different parsers for `double`, `uint64_t` and `int64_t` values. This use-specific parsing avoids the branchiness of a generic "type switch," and makes the code more inlineable and compact.
+* **Validate What You Use:** On Demand deliberately validates the values you use and the structure leading to it, but nothing else. The goal is a guarantee that the value you asked for is the correct one and is not malformed: there must be no confusion over whether you got the right value.
+
+
+
+To understand why On Demand is different, it is helpful to review the major
+approaches to parsing and parser APIs in use today.
+
+### DOM Parsers
+
+Many of the most usable, popular JSON APIs (including simdjson) deserialize into a **DOM**: an intermediate tree of
+objects, arrays and values. In this model, we convert the input data all at once into a tree-like structure (the DOM).
+The DOM is then accessed by the programmer like any other in-memory data structure. The resulting API let
+you refer to each array or object separately, using familiar techniques like iteration (`for (auto value : array)`)
+or indexing (`object["key"]`). In some cases, the values are even deserialized directly into familiar C++ constructs like vectors and
+maps.
+
+The DOM approach is conceptually simple and "programmer friendly". Using the
+DOM tree is often easy enough that many users use the DOM as-is instead of creating
+their own custom data structures.
+
+The DOM approach was the only way to parse JSON documents up to version 0.6 of the simdjson library.
+Our DOM API looks similar to our On Demand example, except
+it calls `parse` instead of `iterate`:
+
+```c++
+dom::parser parser;
+auto doc = parser.parse(json);
+for (auto tweet : doc["statuses"]) {
+  std::string_view text        = tweet["text"];
+  std::string_view screen_name = tweet["user"]["screen_name"];
+  uint64_t         retweets    = tweet["retweet_count"];
+  uint64_t         favorites   = tweet["favorite_count"];
+  cout << screen_name << " (" << retweets << " retweets / " << favorites << " favorites): " << text << endl;
+}
+```
+
+Pros of the DOM approach:
+* Straightforward, programmer-friendly interface (arrays and objects).
+* Safe: all of the input data has been validated before it is accessed.
+* All of the JSON document is available at once to the programmer.
+
+Cons of the DOM approach:
+* The memory usage scales linearly with the size of the input document.
+* Parses and stores everything, using memory and CPU cycles even on unused values.
+* Performance drain from [type blindness](#type-blindness).
+
+
+What the simdjson library demonstrates is that a DOM API may be quite fast indeed: we can parse files at speeds
+of several gigabytes per second. However, in some instances, it may be possible to achieve even higher speeds.
+
+### Event-Based Parsers (SAX, SAJ, etc.)
+
+
+The event-based model (originally from the "Streaming API for XML") uses streaming to eliminate the cost of
+parsing and storing the entire JSON. In the event-based model, a core JSON engine parses the JSON document
+piece by piece, but instead of stuffing values in a DOM tree, it passes each value to a callback function,
+letting the user decide for themselves how to handle it. In such a model, the programmer may need to provide functions
+for all possible events (a number, a string, a new object, a new array, the array ends, the object ends, and so on).
+This allows programmers to work with much larger files without running out of memory.
+
+The drawback is complexity: event-based APIs generally have you define a single callback for each type
+(e.g. `string_field(std::string_view key, std::string_view value)`). Because of this, the programmer suffers
+from context blindness: when they find a string they have to check where it is before they know what to
+do with it. Is this string the text of the tweet, the screen name, or something else? Are we even in
+a tweet right now, or is this from some other place in the document
+entirely? Though an event-based approach may allow superior performance, it is demanding of the programmer
+who must efficiently keep track of its current state within the JSON input.
+
+The following is event-based example of the Twitter problem we have reviewed in the DOM and On Demand
+examples. To make it short enough to use as an example at all, it has heavily redacted: it only solves
+a part of the problem (does not get user.screen_name), it has bugs (it does not handle sub-objects
+in a tweet at all), and it uses a theoretical, simple event-based API that minimizes ceremony.
+
+```c++
+struct twitter_callbacks {
+  bool in_statuses;
+  bool in_tweet;
+  std::string_view text;
+  uint64_t         retweets;
+  uint64_t         favorites;
+  void start_object_field(std::string_view key) {
+    if (key == "statuses") { in_statuses = true; }
+  }
+  void start_object() {
+    if (in_statuses) { in_tweet = true; }
+  }
+  void string_field(std::string_view key, std::string_view value) {
+    if (in_tweet && key == "text") { text = value; }
+  }
+  void number_field(std::string_view key, uint64_t value) {
+    if (in_tweet) {
+      if (key == "retweet_count") { retweets = value; }
+      if (key == "favorite_count") { favorites = value; }
+    }
+  }
+  void end_object() {
+    if (in_tweet) {
+      cout << "[redacted] (" << retweets << " retweets / " << favorites << " favorites): " << text << endl;
+      in_tweet = false;
+    } else if (in_statuses) {
+      in_statuses = false;
+    }
+  }
+};
+sax::parser parser;
+parser.parse(twitter_callbacks());
+```
+
+This is a large amount of code, requiring mental gymnastics even to read. An actual implementation is  harder to write
+and to maintain.
+
+
+Pros of the event-based approach:
+* Speed and space benefits from low, predictable memory usage.
+* Parsing can be done more lazily: the API can delegate work to the programmer for better performance.
+* It is highly flexible: given enough effort, most tasks can be accomplished efficiently.
+
+Cons of the event-based approach:
+* Performance drain from context blindness (e.g., switch statements for "where am I in the document")
+* Difficult to use (high code complexity, high maintenance, difficult to debug)
+* Lacks the safety of DOM: malformed documents could be ingested.
+
+Though an event-based approach might have its niche uses, we believe that it is rarely ideally suited. We suspect that it is mostly used when performance and memory is a concern, and no other option (except DOM) is readily available.
+
+### Schema-Based Parser Generators
+
+
+In a schema-based model, the programmer provides a description of a data structure, and the parser constructs the data structure in question during parsing. These parsers take a schema--a description of
+your JSON, with field names, types, everything--and generate classes/structs in your language of
+choice, as well as a parser to deserialize the JSON into those structs. Some such parsers let you
+define your own data structures (`struct`) and they let a preprocessor inspects it and generates a custom JSON parser for it.
+Though not all of these schema-based parser generators generate a parser or even optimize for
+streaming, but they are *able* to in principle. Unlike the DOM and the event-based models, a schema-based approach assumes
+ that the structure of the document is known at compile-time.
+
+
+Pros of the schema-based approach:
+* Ease of Use is on par with DOM
+* Parsers that generate iterators and lazy values in structs can keep memory pressure down to event-based levels.
+* Type Blindness can be entirely solved with specific parsers for each type, saving many branches.
+* Context Blindness can be solved, especially if object fields are required and in order, saving even more branches.
+* Can be made a safe as DOM: the input can be entirely validated prior to ingestion.
+
+Cons of the schema-based approach:
+* It is less flexible than the DOM or event-based approaches, sometimes limited to a deserialization-to-objects scenario.
+* The structure of the data must be fully known at compile-time.
+
+
+### Type Blindness and Branch Misprediction
+
+The DOM and event-based parsing model suffer from **type
+blindness**: even when the programmer knows exactly what fields and what types are in the JSON document,
+the parser does not. This means it has to look at each value blind with a big "switch"
+statement, asking "is this a number? A string? A boolean? An array? An object?"
+
+In modern processors, this kind of switch statement can make your program run slower
+than it needs to because of the high cost of branch misprediction. Indeed, modern processor
+cores rely on speculative execution for speed. They "read ahead" in your program, predicting
+which instructions to run as soon as the data is available. A single-threaded program can
+execute 2, 3 or even more instructions per cycle--largely because of speculative execution.
+
+Unfortunately, when the processor mispredicts the instructions, typically due to a mispredicted
+branch, all of the work done from the misprediction has be discarded and started anew. The
+processor may have been executing 3 or 4 instructions per cycle, and consuming the corresponding
+power, but all of the work may have been wasteful.
+
+Type blindness means that the processor has to guess, for every JSON value, whether it will be an array,
+an object, number, string or boolean since these correspond to distinct code paths.
+Though some JSON files have predictable content, we find in practice that many JSON files
+stress the branch prediction. Though branch predictors improve with each new generation of processors,
+the cost of branch mispredictions also tends to increase as pipelines expand, and the processors become
+able to schedule longer streams of instructions.
+
+On Demand parsing is tailor-made to solve this problem at the source, parsing values only after the
+user declares their type by asking for a `double`, an `int`, a `string`, etc. It attempts to do so while
+preserving most of the flexibility of DOM parsing.
+
+Algorithm
+---------
+
+To help visualize the algorithm, we'll walk through the example C++ given at the top, for this JSON:
+
+```json
+{
+  "statuses": [
+    { "id": 1, "text": "first!", "user": { "screen_name": "lemire", "name": "Daniel" }, "favorite_count": 100, "retweet_count": 40 },
+    { "id": 2, "text": "second!", "user": { "screen_name": "jkeiser2", "name": "John" }, "favorite_count": 2, "retweet_count": 3 }
+  ]
+}
+```
+
+### Starting the iteration
+
+1. First, we declare a parser object that keeps internal buffers necessary for parsing. This can be
+   reused to parse multiple JSON files, so you do not pay the high cost of allocating memory every
+   time (and so it can stay in cache!).
+
+   This declaration does not allocate any memory; that will happen in the next step.
+
+   ```c++
+   ondemand::parser parser;
+   ```
+
+2. We then start iterating the JSON document by allocating internal parser buffers, preprocessing
+   the JSON, and initializing the iterator.
+
+   ```c++
+   auto doc = parser.iterate(json);
+   ```
+
+   Since this is the first time this parser has been used, `iterate()` first allocates internal
+   parser buffers if this is the first time through. When reusing an existing parser, allocation
+   only happens if the new document is bigger than internal buffers can handle. The On Demand
+   API only ever allocates memory in the `iterate()` function call.
+
+   The simdjson library then preprocesses the JSON text at high speed, finding all tokens (i.e. the starting
+   position of any JSON value, as well as any important operators like `,`, `:`, `]` or `}`).
+
+   Finally, a `document` iterator is created, initialized at the position of the first value in the
+   `json` text input. The document iterator is bumped forward by array / object iterators and
+   object[] lookup, and must be kept around until iteration is complete.
+
+   This operation can fail as this stage if the document in invalid! The result type is `simdjson_result<document>`.
+   The simdjson library uses `simdjson_result` when a value needs to be returned by a function that can fail given improper inputs.
+   The `simdjson_result` value contain an `error_code` and a `document`, and it was designed to allow you to use either error code
+   checking or C++ exceptions via a direct cast `document(parser.iterate(json))` you can use `get()`
+   to check the error and cast to a value, or cast directly to a value. However, the simdjson library
+   rely on error chaining, so it is possible to delay error checks: we shall shortly explain error
+   chaining more fully.
+
+   NOTE: You should always have such a `document` instance (here `doc`) and it should remain in scope for the duration
+   of your parsing function. E.g., you should not use the returned document as a temporary (e.g., `auto x = parser.iterate(json).get_object();`)
+   followed by other operations as the destruction of the `document` instance makes all of the derived instances
+   ill-defined.
+
+
+3. We iterate over the "statuses" field using a typical C++ iterator, reading past the initial
+   `{ "statuses": [ {`.
+
+   ```c++
+   for (ondemand::object tweet : doc["statuses"]) {
+   ```
+  This shorthand does much, and it is helpful to see what it expands to.
+  Comments in front of each one explain what's going on:
+  ```c++
+  // Validate that the top-level value is an object: check for {
+  ondemand::object top = doc.get_object();
+
+  // Find the field statuses by:
+  // 1. Check whether the object is empty (check for }). (We do not really need to do this unless the key lookup fails!)
+  // 2. Check if we're at the field by looking for the string "statuses" using byte-by-byte comparison.
+  // 3. Validate that there is a `:` after it.
+  auto tweets_field = top["statuses"];
+
+  // Validate that the field value is an array: check for [
+  // Also mark the array as finished if there is a ] next, which would cause the while () statement to exit immediately.
+  ondemand::array tweets = tweets_field.get_array();
+  // These three method calls do nothing substantial (the real checking happens in get_array() and ++)
+  // != checks whether the array is marked as finished (if we have found a ]).
+  ondemand::array_iterator tweets_iter = tweets.begin();
+  while (tweets_iter != tweets.end()) {
+    auto tweet_value = *tweets_iter;
+
+    // Validate that the array element is an object: check for {
+    ondemand::object tweet = tweet_value.get_object();
+    ...
+  }
+  ```
+   What is not explained in this code expansion is *error chaining*.
+   Generally, you can use `document` methods on a `simdjson_result<...>` value; any errors will
+   just be passed down the chain. Many method calls
+   can be chained in this manner. So `for (object tweet : doc["statuses"])`, which is the equivalent of
+   `object tweet = *(doc.get_object()["statuses"].get_array().begin()).get_object()`, could fail in any of
+   6 method calls, and the error will only be checked at the end,
+   when you attempt to cast the final `simdjson_result<object>` to object. Upon casting, an exception is
+   thrown if there was an error.
+
+   NOTE: while the document can be queried once for a key as if it were an object, it is not an actual object
+   instance. If you need to treat it as an object (e.g., to query more than one keys), you can cast it as
+   such `ondemand::object root_object = doc.get_object();`.
+
+
+4. We get the `"text"` field as a string.
+
+   ```c++
+   std::string_view text        = tweet["text"];
+   ```
+
+   First, `["text"]` skips the `"id"` field because it does not match: skips the key, `:` and
+   value (`1`). We then check whether there are more fields by looking for either `,`
+   or `}`.
+
+   The second field is matched (`"text"`), so we validate the `:` and move to the actual value.
+
+   NOTE: `["text"]` does a *raw match*, comparing the key directly against the raw JSON. This means
+   that keys with escapes in them may not be matched and the letter case must match exactly.
+
+   To convert to a string, we check for `"` and use simdjson's fast unescaping algorithm to copy
+   `first!` (plus a terminating `\0`) into a buffer managed by the `document`. This buffer stores
+   all strings from a single iteration. The next string will be written after the `\0`.
+
+   A `string_view` is returned which points to that buffer, and contains the length.
+
+4. We get the `"screen_name"` from the `"user"` object.
+
+   ```c++
+      ondemand::object user        = tweet["user"];
+      screen_name                  = user["screen_name"];
+   ```
+
+   First, `["user"]` checks whether there are any more object fields by looking for either `,` or
+  `}`. Then it matches `"user"` and validates the `:`.
+
+   `["screen_name"]` then converts to object, checking for `{`, and finds `"screen_name"`.
+
+   To convert the result to usable string (i.e., the screen name `lemire`), the characters are written to the document's
+   string buffer (after possibly escaping them), which now has *two* string_views pointing into it, and looks like `first!\0lemire\0`.
+
+   Finally, the temporary user object is destroyed, causing it to skip the remainder of the object
+   (`}`).
+
+   NOTE: You may only have one active array or object active at any given time. An array or an object becomes
+   active when the `ondemand::object` or `ondemand::array` is created, and it releases its 'focus' when
+   its destructor is called. If you create an array or an object located inside a parent object or array,
+   the child array or object becomes active while the parent becomes temporarily inactive. If you access
+   several sibling objects or arrays, you must ensure that the destructor is called by scoping each access
+   (see Iteration Safety section below for further details).
+
+5. We get `"retweet_count"` and `"favorite_count"` as unsigned integers.
+
+   ```c++
+   uint64_t         retweets    = tweet["retweet_count"];
+   uint64_t         favorites   = tweet["favorite_count"];
+   ```
+
+6. We loop to the next tweet.
+
+   ```c++
+   for (ondemand::object tweet : doc["statuses"]) {
+     ...
+   }
+   ```
+
+   The relevant parts of the loop  are:
+
+   ```c++
+   while (iter != statuses.end()) {
+     ondemand::object tweet = *iter;
+     ...
+     iter++;
+   }
+   ```
+
+   First, the `tweet` destructor runs, skipping the remainder of the object which in this case is
+   just `}`.
+
+   Next, `iter++` checks whether there are more values and finds `,`. The loop continues.
+
+   Finally, `ondemand::object tweet = *iter` checks for `{` and returns the object.
+
+   This tweet is processed just like the previous one.
+
+7. We finish the last tweet.
+
+   At the end of the loop, the `tweet` is first destroyed, skipping the remainder of the tweet
+   object (`}`).
+
+   The `iter++` instruction from `for (ondemand::object tweet : doc["statuses"])` then checks whether there are
+   more values and finds that there are none (`]`). It marks the array iteration as finished and the for
+   loop terminates.
+
+   Then the outer object is destroyed, skipping everything up to the `}`.
+
+Design Features
+---------------
+
+### String Parsing
+
+When the user requests strings, we unescape them to a single string buffer much like the DOM parser
+so that users enjoy the same string performance as the core simdjson. We do not write the length to the
+string buffer, however; that is stored in the `string_view` instance we return to the user.
+
+```C++
+  ondemand::parser parser;
+  auto doc = parser.iterate(json);
+  std::set<std::string_view> default_users;
+  ondemand::array tweets = doc["statuses"].get_array();
+  for (auto tweet_value : tweets) {
+    auto tweet = tweet_value.get_object();
+    ondemand::object user = tweet["user"].get_object();
+    std::string_view screen_name = user["screen_name"].get_string();
+    bool default_profile = user["default_profile"].get_bool();
+    if (default_profile) { default_users.insert(screen_name); }
+  }
+```
+
+By using `string_view` instances, we avoid the high cost of allocating many small strings (as would be the
+case with `std::string`) but be mindful that the life cycle of these `string_view` instances is tied to the
+parser instance. If the parser instance is destroyed or reused for a new JSON document, these strings are no longer valid.
+
+We iterate through object instances using `field` instances which represent key-value pairs. The value
+is accessible by the `value()` method whereas the key is accessible by the `key()` method.
+The keys are treated differently than values are made available as as special type `raw_json_string`
+which is a lightweight type that is meant to be used on a temporary basis, amost solely for
+direct raw ASCII comparisons (`field.key() == "mykey"`). If you occasionally need to access and store the
+unescaped key values, you may use the `unescaped_key()` method. Once you have called `unescaped_key()` method,
+neither the `key()` nor the `unescaped_key()` methods should be called: the current field instance
+has no longer a key (that is by design). Like other strings, the resulting `std::string_view` generated
+from the `unescaped_key()` method has a lifecycle tied to the `parser` instance: once the parser
+is destroyed or reused with another document, the `std::string_view` instance becomes invalid.
+
+
+```C++
+auto doc = parser.iterate(json);
+for(auto field : doc.get_object())  {
+      std::string_view keyv = field.unescaped_key();
+}
+```
+
+### Iteration Safety
+
+The On Demand API is powerful. To compensate, we add some safeguards to ensure that it can be used without fear
+in production systems:
+
+  - If the value fails to be parsed as one type, the program can try to parse it as something else until the program succeeds. Thus
+    the programmer can engineer fall back routines.
+  - If the value succeeds in being parsed or converted to a type, the program cannot try again. An attempt to parse the same node twice will
+    cause the program to abort. We put this safety measure in the API to prevent double iteration of an array which
+    would cause inconsistent iterator state or double-unescaping a string which may cause memory
+    overruns if done.
+  - Guaranteed Iteration: If you discard a value without using it--perhaps you just wanted to know
+    if it was `nullptr` but did not care what the actual value was--it will iterate. The destructor automates
+    the iteration.
+
+  Some care is needed when using the On Demand API in scenarios where you need to access several sibling arrays or objects because
+  only one object or array can be active at any one time. Let us consider the following example:
+
+```C++
+    ondemand::parser parser;
+    const padded_string json = R"({ "parent": {"child1": {"name": "John"} , "child2": {"name": "Daniel"}} })"_padded;
+    auto doc = parser.iterate(json);
+    ondemand::object parent = doc["parent"];
+    // parent owns the focus
+    ondemand::object c1 = parent["child1"];
+    // c1 owns the focus
+    //
+    if(std::string_view(c1["name"]) != "John") { ... }
+    // c2 attempts to grab the focus from parent but fails
+    ondemand::object c2 = parent["child2"];
+    // c2 is now in an unsafe state and the following line would be unsafe
+    // if(std::string_view(c2["name"]) != "Daniel") { return false; }
+```
+
+    A correct usage is given by the following example:
+
+```C++
+    ondemand::parser parser;
+    const padded_string json = R"({ "parent": {"child1": {"name": "John"} , "child2": {"name": "Daniel"}} })"_padded;
+    auto doc = parser.iterate(json);
+    ondemand::object parent = doc["parent"];
+    // At this point, parent owns the focus
+    {
+      ondemand::object c1 = parent["child1"];
+      // c1 grabbed the focus from parent
+      if(std::string_view(c1["name"]) != "John") { return false; }
+    }
+    // c1 went out of scope, so its destructor was called and the focus
+    // was handed back to parent.
+    {
+      ondemand::object c2 = parent["child2"];
+      // c2 grabbed the focus from parent
+      // the following is safe:
+      if(std::string_view(c2["name"]) != "Daniel") { return false; }
+    }
+```
+
+### Benefits of the On Demand Approach
+
+We expect that the On Demand approach has many of the performance benefits of the schema-based approach, while providing a flexibility that is similar to that of the DOM-based approach.
+
+* Faster than DOM in some cases. Reduced memory usage.
+* Straightforward, programmer-friendly interface (arrays and objects).
+* Highly expressive, beyond deserialization and pointer queries: many tasks can be accomplished with little code.
+
+### Limitations of the On Demand Approach
+
+The On Demand approach has  some limitations:
+
+* Because it operates in streaming mode, you only have access to the current element in the JSON document. Furthermore, the document is traversed in order so the code is sensitive to the order of the JSON nodes in the same manner as an event-based approach (e.g., SAX).
+* The On Demand approach is less safe than DOM: we only validate the components of the JSON document that are used and it is possible to begin ingesting an invalid document only to find out later that the document is invalid. Are you fine ingesting a large JSON document that starts with well formed JSON but ends with invalid JSON content?
+
+There are currently additional technical limitations which we expect to resolve in future releases of the simdjson library:
+
+* The simdjson library offers runtime dispatching which allows you to compile one binary and have it run at full speed on different processors, taking advantage of the specific features of the processor. The On Demand API does not have runtime dispatch support at this time. To benefit from the On Demand API, you must compile your code for a specific processor. E.g., if your processor supports AVX2 instructions, you should compile your binary executable with AVX2 instruction support (by using your compiler's commands). If you are sufficiently technically proficient, you can implement runtime dispatching within your application, by compiling your On Demand code for different processors.
+* There is an initial phase which scans the entire document quickly, irrespective of the size of the document. We plan to break this phase into distinct steps for large files in a future release as we have done with other components of our API (e.g., `parse_many`).
+* The On Demand API does not support JSON Pointer. This capability is currently limited to our core API.
+* You should be mindful that the though your software might write the keys in a consistent manner, the [JSON specification](https://www.rfc-editor.org/rfc/rfc8259.txt) states that "JSON parsing libraries have been observed to differ as to whether or not they make the ordering of object members visible". The On Demand API will help the programmer handle unexpected JSON dialects by throwing an exception when the unexpected occurs, but the programmer is responsible for handling such cases: e.g., by rejecting the JSON input that does not follow the expected JSON dialect. We intend to help users who wish to use the On Demand API but require support for order-insensitive semantics, but in our current implementation support for out-of-order keys (if needed) must be provided by the programmer. Currently, one might proceed in the following manner as a fallback measure if keys can appear in any order:
+```C++
+    for (ondemand::object my_object : doc["mykey"]) {
+      for (auto field : my_object) {
+        if      (field.key() == "key_value1") { process1(field.value()); }
+        else if (field.key() == "key_value2") { process2(field.value()); }
+        else if (field.key() == "key_value3") { process3(field.value()); }
+      }
+    }
+```
+
+### Applicability of the On Demand Approach
+
+At this time we recommend the On Demand API in the following cases:
+
+1. The 64-bit hardware (CPU) used to run the software is known at compile time. If you need runtime dispatching because you cannot be certain of the hardware used to run your software, you will be better served with the core simdjson API. (This only applies to x64 (AMD/Intel). On 64-bit ARM hardware, runtime dispatching is unnecessary.)
+2. The used parts of JSON files do not need to be validated and the layout of the nodes follows a strict JSON dialect. If you are receiving JSON from other systems, you might be better served with core simdjson API as it fully validates the JSON inputs and allows you to navigate through the document at will.
+3. Speed and efficiency are of the utmost importance. Keep in mind that the core simdjson API is highly efficient so adopting the On Demand API is not necessary for high efficiency.
+4. As a developer, you value a clean, flexible and maintainable API.
+
+Good applications for the On Demand API might be:
+
+* You are working from pre-existing large JSON files that have been vetted. You expect them to be well formed according to a known JSON dialect and to have a consistent layout. For example, you might be doing biomedical research or machine learning on top of static data dumps in JSON.
+* You have a closed system on predetermined hardware. Both the generation and the consumption of JSON data is within your system. Your team controls both the software that produces the JSON and the software the parses it, your team knows and control the hardware. Thus you can fully test your system.
+* You are working with stable JSON APIs which have a consistent layout and JSON dialect.
+
+## Checking Your CPU Selection
+
+Given that the On Demand API does not offer runtime dispatching, your code is compiled against a specific CPU target. You should
+verify that the code is compiled against the target you expect: `haswell` (AVX2 x64 processors), `westmere` (SSE4 x64 processors), `arm64` (64-bit ARM), `ppc64` (64-bit POWER), `fallback` (others). Under x64 processors, many programmers will want to target `haswell` whereas under ARM,
+most programmers will want to target `arm64`. The `fallback` is probably only good for testing purposes, not for deployment.
+
+```C++
+  std::cout << simdjson::builtin_implementation()->name() << std::endl;
+```
+
+If you are using CMake for your C++ project, then you can pass compilation flags to your compiler by using
+the `CMAKE_CXX_FLAGS` variable:
+
+```
+cmake  -DCMAKE_CXX_FLAGS="-march=haswell" -B build_haswell
+cmake --build build_haswell
+```
@@ -1,7 +1,7 @@
 parse_many
 ==========

-An interface providing features to work with files or streams containing multiple JSON documents.
+An interface providing features to work with files or streams containing multiple small JSON documents.
 As fast and convenient as possible.

 Contents
@@ -13,17 +13,19 @@ Contents
 - [Support](#support)
 - [API](#api)
 - [Use cases](#use-cases)
+- [Tracking your position](#tracking-your-position)
+- [Incomplete streams](#incomplete-streams)

-Motivations
+Motivation
 -----------

 The main motivation for this piece of software is to achieve maximum speed and offer a
-better quality of life in parsing files containing multiple JSON documents.
+better quality of life in parsing files containing multiple small JSON documents.

-The JavaScript Object Notation (JSON) [RFC7159](https://tools.ietf.org/html/rfc7159) is a very handy
+The JavaScript Object Notation (JSON) [RFC7159](https://tools.ietf.org/html/rfc7159) is a handy
 serialization format.  However, when serializing a large sequence of
 values as an array, or a possibly indeterminate-length or never-
-ending sequence of values, JSON becomes difficult to work with.
+ending sequence of values, JSON may be inconvenient.

 Consider a sequence of one million values, each possibly one kilobyte
 when encoded -- roughly one gigabyte.  It is often desirable to process such a dataset incrementally
@@ -32,9 +34,9 @@ without having to first read all of it before beginning to produce results.
 Performance
 -----------

-Here is a chart comparing the speed of the different alternatives to parse a multiline JSON.
-The simdjson library provides a threaded and non-threaded parse_many() implementation.  As the
-figure below shows, if you can, use threads, but if you can't, it's still pretty fast!
+The following is a chart comparing the speed of the different alternatives to parse a multiline JSON.
+The simdjson library provides a threaded and non-threaded `parse_many()` implementation.  As the
+figure below shows, if you can, use threads, but if you cannot, the unthreaded mode is still fast!
 [![Chart.png](/doc/Multiline_JSON_Parse_Competition.png)](/doc/Multiline_JSON_Parse_Competition.png)

 How it works
@@ -71,7 +73,7 @@ allocate enough memory so that all the documents can fit. This value is what we
 As of right now, we need to manually specify a value for this batch size, it has to be at least as
 big as the biggest document in your file, but not too big so that it submerges the cached memory.
 The bigger the batch size, the fewer we need to make allocations. We found that 1MB is somewhat a
-sweet spot for now.
+sweet spot.

 1. When the user calls `parse_many`, we return a `document_stream` which the user can iterate over
   to receive parsed documents.
@@ -158,3 +160,58 @@ From [jsonlines.org](http://jsonlines.org/examples/):
    ```
    JSON Lines' biggest strength is in handling lots of similar nested data structures. One .jsonl file is easier to
    work with than a directory full of XML files.
+
+
+Tracking your position
+-----------
+
+Some users would like to know where the document they parsed is in the input array of bytes.
+It is possible to do so by accessing directly the iterator and calling its `current_index()`
+method which reports the location (in bytes) of the current document in the input stream.
+
+Let us illustrate the idea with code:
+
+
+```C++
+    auto json = R"([1,2,3]  {"1":1,"2":3,"4":4} [1,2,3]  )"_padded;
+    simdjson::dom::parser parser;
+    simdjson::dom::document_stream stream;
+    ASSERT_SUCCESS( parser.parse_many(json).get(stream) );
+    auto i = stream.begin();
+    for(; i != stream.end(); ++i) {
+        auto doc = *i;
+        if(!doc.error()) {
+          std::cout << "got full document at " << i.current_index() << std::endl;
+        }
+    }
+    size_t index = i.current_index();
+    if(index != 38) {
+      std::cerr << "Expected to stop after the three full documents " << std::endl;
+      std::cerr << "index = " << index << std::endl;
+      return false;
+    }
+```
+
+This code will print:
+```
+got full document at 0
+got full document at 9
+got full document at 29
+```
+
+The last call to `i.current_index()` return the byte index 38, which is just beyond
+the last document.
+
+Incomplete streams
+-----------
+
+Some users may need to work with truncated streams while tracking their location in the stream.
+The same code, with the `current_index()` will work. However, the last block (by default 1MB)
+terminates with an unclosed string, then no JSON document within this last block will validate.
+In particular, it means that if your input string is `[1,2,3]  {"1":1,"2":3,"4":4} [1,2` then
+no JSON document will be successfully parsed. The error `simdjson::UNCLOSED_STRING` will be
+given (even with the first JSON document). It is then your responsability to terminate the input
+maybe by appending the missing data at the end of the truncated string, or by copying the truncated
+data before the continuing input.
+
+
@@ -12,6 +12,8 @@ are still some scenarios where tuning can enhance performance.
 * [Visual Studio](#visual-studio)
 * [Downclocking](#downclocking)
 * [Best Use of the DOM API](#best-use-of-the-dom-api)
+* [Padding and Temporary Copies](#padding-and-temporary-copies)
+

 Reusing the parser for maximum efficiency
 -----------------------------------------
@@ -155,7 +157,7 @@ Downclocking

 SIMD instructions are the public transportation of computing. Instead of using 4 distinct instructions to add numbers, you can replace them with a single instruction that does the same work. Though the one instruction is slightly more expensive, the energy used per unit of work is much less with SIMD. If you can increase your speed using SIMD instructions (NEON, SSE, AVX), you should expect to reduce your power usage.

-The SIMD instructions that simdjson relies upon (SSE and AVX under x64, NEON under ARM) are routinely part of runtime libraries (e.g., [Go](https://golang.org/src/runtime/memmove_amd64.s), [Glibc](https://github.com/ihtsae/glibc/commit/5f3d0b78e011d2a72f9e88b0e9ef5bc081d18f97), [LLVM](https://github.com/llvm/llvm-project/blob/96f3ea0d21b48ca088355db10d4d1a2e9bc9f884/lldb/tools/debugserver/source/MacOSX/i386/DNBArchImplI386.cpp), [Rust](https://github.com/rust-lang/rust/commit/070fad1701fb36b112853b0a6a9787a7bb7ff34c), [Java](http://hg.openjdk.java.net/jdk8u/jdk8u/hotspot/file/c1374141598c/src/cpu/x86/vm/stubGenerator_x86_64.cpp#l1297), [PHP](https://github.com/php/php-src/blob/e5cb53ec68603d4dbdd780fd3ecfca943b4fd383/ext/standard/string.c)). What distinguishes the simdjson library is that it is built from the ground up to benefit from these instructions. 
+The SIMD instructions that simdjson relies upon (SSE and AVX under x64, NEON under ARM, ALTIVEC under PPC) are routinely part of runtime libraries (e.g., [Go](https://golang.org/src/runtime/memmove_amd64.s), [Glibc](https://github.com/ihtsae/glibc/commit/5f3d0b78e011d2a72f9e88b0e9ef5bc081d18f97), [LLVM](https://github.com/llvm/llvm-project/blob/96f3ea0d21b48ca088355db10d4d1a2e9bc9f884/lldb/tools/debugserver/source/MacOSX/i386/DNBArchImplI386.cpp), [Rust](https://github.com/rust-lang/rust/commit/070fad1701fb36b112853b0a6a9787a7bb7ff34c), [Java](http://hg.openjdk.java.net/jdk8u/jdk8u/hotspot/file/c1374141598c/src/cpu/x86/vm/stubGenerator_x86_64.cpp#l1297), [PHP](https://github.com/php/php-src/blob/e5cb53ec68603d4dbdd780fd3ecfca943b4fd383/ext/standard/string.c)). What distinguishes the simdjson library is that it is built from the ground up to benefit from these instructions.


 You should not expect the simdjson library to cause *downclocking* of your recent Intel CPU cores.
@@ -165,7 +167,7 @@ On some Intel processors, using SIMD instructions in a sustained manner on the s
 - [Whenever 512-bit AVX-512 instructions are used](https://lemire.me/blog/2018/09/07/avx-512-when-and-how-to-use-these-new-instructions/).
 - Whenever heavy 256-bit or wider instructions are used. Heavy instructions are those involving floating point operations or integer multiplications (since these execute on the floating point unit).

-The simdjson library does not currently support AVX-512 instructions and it does not make use of heavy 256-bit instructions. We do use vectorized multiplications, but only using 128-bit registers. Thus there should be no downclocking due to simdjson on recent processors. 
+The simdjson library does not currently support AVX-512 instructions and it does not make use of heavy 256-bit instructions. We do use vectorized multiplications, but only using 128-bit registers. Thus there should be no downclocking due to simdjson on recent processors.

 You may still be worried about which SIMD instruction set is used by simdjson.  Thankfully,  [you can always determine and change which architecture-specific implementation is used](implementation-selection.md) by simdjson. Thus even if your CPU supports AVX2, you do not need to use AVX2. You are in control.

@@ -174,3 +176,25 @@ Best Use of the DOM API

 The simdjson API provides access to the JSON DOM (document-object-model) content as a tree of `dom::element` instances, each representing an object, an array or an atomic type (null, true, false, number). These `dom::element` instances are lightweight objects (e.g., spanning 16 bytes) and it might be advantageous to pass them by value, as opposed to passing them by reference or by pointer.

+Padding and Temporary Copies
+--------------
+
+The simdjson function `parser.parse` reads data from a padded  buffer, containing SIMDJSON_PADDING extra bytes added at the end.
+If you are passing a `padded_string` to `parser.parse` or loading the JSON directly from
+disk (`parser.load`), padding is automatically  handled.
+When calling `parser.parse` on a pointer (e.g., `parser.parse(my_char_pointer, my_length_in_bytes)`) a temporary copy  is made by default with adequate padding and you, again, do not need to be concerned with padding.
+
+Some users may not be able use our `padded_string` class or to load the data directly from disk (`parser.load`). They may need to pass data pointers to the library.  If these users wish to avoid temporary copies and corresponding temporary memory allocations, they may want to call `parser.parse` with the `realloc_if_needed` parameter set to false (e.g., `parser.parse(my_char_pointer, my_length_in_bytes, false)`). In such cases, they need to ensure that there are at least SIMDJSON_PADDING extra bytes at the end that can be safely accessed and read. They do not need to initialize the padded bytes to any value in particular. The following example is safe:
+
+
+```C++
+const char *json      = R"({"key":"value"})";
+const size_t json_len = std::strlen(json);
+std::unique_ptr<char[]> padded_json_copy{new char[json_len + SIMDJSON_PADDING]};
+memcpy(padded_json_copy.get(), json, json_len);
+memset(padded_json_copy.get() + json_len, 0, SIMDJSON_PADDING);
+simdjson::dom::parser parser;
+simdjson::dom::element element = parser.parse(padded_json_copy.get(), json_len, false);
+````
+
+Setting the `realloc_if_needed` parameter `false` in this manner may lead to better performance since copies are avoided, but it requires that the user takes more responsibilities: the simdjson library cannot verify that the input buffer was padded with SIMDJSON_PADDING extra bytes.
--- a/Show More
+++ b/Show More