Issue release

Update README.md
2026-06-08 17:27:07 +00:00 · 2020-10-23 09:32:25 -04:00 · 2020-10-23 09:21:16 -04:00 · 2020-10-23 09:18:47 -04:00 · 2020-10-23 09:15:04 -04:00 · 2020-10-23 08:47:01 -04:00
700 changed files with 80830 additions and 29138 deletions
@@ -1,29 +1,46 @@
 version: '{build}'
-branches:
-  only:
-  - master
-image:
-    - Visual Studio 2017
-clone_folder: c:\projects\simdjson
-
-platform:
- x64
+branches: { only: [ master ] }
+configuration: Release
+image: Visual Studio 2019
+platform: x64

 environment:
  matrix:
-    - SIMDJSON_BUILD_STATIC: "OFF"
-      THREADS: "ON"
-    - SIMDJSON_BUILD_STATIC: "OFF"
-      THREADS: "OFF"
-    - SIMDJSON_BUILD_STATIC: "ON"
-      THREADS: "ON"
-#    - SIMDJSON_BUILD_STATIC: "ON"
-#      THREADS: "OFF"
-      
+    - job_name: VS2019
+      CMAKE_ARGS:  -A %Platform%
+    - job_name: VS2019ARM
+      CMAKE_ARGS: -A ARM64 -DCMAKE_CROSSCOMPILING=1 -D SIMDJSON_GOOGLE_BENCHMARKS=OFF # Does Google Benchmark builds under VS ARM?
+    - job_name: VS2017 (Static, No Threads)
+      image: Visual Studio 2017
+      CMAKE_ARGS:  -A %Platform% -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_ENABLE_THREADS=OFF
+      CTEST_ARGS: -E checkperf
+    - 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|ondemand_basictests"
+    - job_name: VS2015
+      image: Visual Studio 2015
+      CMAKE_ARGS:  -A %Platform% -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_ENABLE_THREADS=OFF
+      CTEST_ARGS: -E checkperf
+
 build_script:
  - mkdir build
  - cd build
-  - ps: cmake -DSIMDJSON_BUILD_STATIC="$env:SIMDJSON_BUILD_STATIC" -DSIMDJSON_ENABLE_THREADS="$env:THREADS" -DCMAKE_BUILD_TYPE=Release -DCMAKE_GENERATOR_PLATFORM=x64 -DSIMDJSON_GOOGLE_BENCHMARKS=OFF ..
-  - cmake --build .
-  - ctest --verbose --output-on-failure
+  - cmake --version
+  - cmake %CMAKE_ARGS% --parallel ..
+  - cmake -LH ..
+  - cmake --build . --config %Configuration% --verbose --parallel

+for:
+-
+  matrix:
+    except:
+      - job_name: VS2019ARM
+
+  test_script:
+    - ctest --output-on-failure -C %Configuration% --verbose %CTEST_ARGS% --parallel
+
+clone_folder: c:\projects\simdjson
+
+matrix:
+  fast_finish: true
@@ -1,226 +1,269 @@
 version: 2.1

+
+# We constantly run out of memory so please do not use parallelism (-j, -j4). 
+
 # Reusable image / compiler definitions
 executors:
-  gcc7:
-    docker:
-      - image: gcc:7
-        environment:
-          CXX: g++
  gcc8:
    docker:
-      - image: gcc:8
+      - image: conanio/gcc8
        environment:
-          CXX: g++
+          CXX: g++-8
+          CC: gcc-8
+          BUILD_FLAGS: 
+          CTEST_FLAGS: --output-on-failure
+
  gcc9:
    docker:
-      - image: gcc:9
+      - image: conanio/gcc9
        environment:
-          CXX: g++
+          CXX: g++-9
+          CC: gcc-9
+          BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  gcc10:
+    docker:
+      - image: conanio/gcc10
+        environment:
+          CXX: g++-10
+          CC: gcc-10
+          BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  clang10:
+    docker:
+      - image: conanio/clang10
+        environment:
+          CXX: clang++-10
+          CC: clang-10
+          BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  clang9:
+    docker:
+      - image: conanio/clang9
+        environment:
+          CXX: clang++-9
+          CC: clang-9
+          BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure 
+
  clang6:
    docker:
-      - image: ubuntu:18.04
+      - image: conanio/clang60
        environment:
          CXX: clang++-6.0
+          CC: clang-6.0
+          BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure

 # Reusable test commands (and initializer for clang 6)
 commands:
-  init_clang6:
-    steps:
-      - run: apt-get update -qq
-      - run: apt-get install -y clang build-essential git
-  make_test:
-    steps:
-      - checkout
-      - run: make
-      - run: make amalgamate
-      - run: ARCHFLAGS=-march=haswell make amalgamate # some users do this: https://github.com/lemire/simdjson/issues/444
-      - run: make test
-      - run: make checkperf
-      - run: make clean
-      - run: ARCHFLAGS=-march=haswell make test # this breaks runtime dispatch, but see https://github.com/lemire/simdjson/issues/444... this is a code robustness test
-      - run: make clean
-      - run: EXTRAFLAGS=-DSIMDJSON_NO_COMPUTED_GOTO=true make test # this should run tests with computed gotos disabled
-  make_test_strict: # this version fails when a warning is detected.
-    steps:
-      - checkout
-      - run: EXTRAFLAGS=-Werror make
-      - run: EXTRAFLAGS=-Werror make amalgamate
-      - run: ARCHFLAGS=-march=haswell make amalgamate # some users do this: https://github.com/lemire/simdjson/issues/444
-      - run: EXTRAFLAGS=-Werror make quicktests
-      - run: make clean
-  
-  cmake_simple_test: # this version just builds and test
+  install_cmake:
    steps:
      - run: apt-get update -qq
      - run: apt-get install -y cmake
-      - checkout
-      - run: cmake $CMAKE_TEST_FLAGS
-      - run: make all
-      - run: make test

-  cmake_test: # this version builds, install, test and then verifyi from the installation
+  cmake_prep:
    steps:
-      - run: apt-get update -qq
-      - run: apt-get install -y cmake
      - checkout
-      - run: cmake $CMAKE_TEST_FLAGS  -DCMAKE_INSTALL_PREFIX:PATH=destination
-      - run: make all install
-      - run: make test
-      - run: echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json # we not only want cmake to build and run tests, but we want also a succesful installation from which we can build, link and run programs
+      - run: mkdir -p build
+
+  cmake_build_cache:
+    steps:
+      - cmake_prep
+      - run: cmake $CMAKE_FLAGS -DCMAKE_INSTALL_PREFIX:PATH=destination -B build . 
+
+  cmake_build:
+    steps:
+      - cmake_build_cache
+      - run: cmake --build build
+
+  cmake_test:
+    steps:
+      - cmake_build
+      - run: |
+          cd build &&
+          tools/json2json -h &&
+          ctest $CTEST_FLAGS -L acceptance &&
+          ctest $CTEST_FLAGS -LE acceptance -E checkperf
+
+  cmake_test_all:
+    steps:
+      - cmake_build
+      - run: |
+          cd build &&
+          tools/json2json -h &&
+          ctest $CTEST_FLAGS -DSIMDJSON_IMPLEMENTATION="haswell;westmere;fallback" -L acceptance -LE per_implementation &&
+          SIMDJSON_FORCE_IMPLEMENTATION=haswell ctest $CTEST_FLAGS -L per_implementation -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:
+      - run: cd build && make install
+      - run: echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Ibuild/destination/include -Lbuild/destination/lib -std=c++17 -Wl,-rpath,build/destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json
+
+  cmake_installed_test_cxx20: # assuming that it was installed, this tries to build using C++20
+    steps:
+      - run: echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Ibuild/destination/include -Lbuild/destination/lib -std=c++20 -Wl,-rpath,build/destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json

 jobs:

-  gcc-avx-unthreaded:
-    description: Build, run tests and check performance on GCC 7 and AVX 2 *without* threads
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
+  # static
+  justlib-gcc10:
+    description: Build just the library, install it and do a basic test
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_JUST_LIBRARY=ON }
+    steps: [ cmake_build, cmake_install_test, cmake_installed_test_cxx20 ]
+  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
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_BUILD_STATIC=ON }
+    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
+  clang6:
+    description: Build and run tests on clang 6 and AVX 2 with a cmake static build
+    executor: clang6
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_BUILD_STATIC=ON }
+    steps: [ cmake_test, cmake_install_test ]
+  clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake static build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON  -DSIMDJSON_BUILD_STATIC=ON }
+    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
+  # libcpp
+  libcpp-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake static build and libc++
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_USE_LIBCPP=ON  -DSIMDJSON_BUILD_STATIC=ON }
+    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
+  # sanitize
+  sanitize-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON, BUILD_FLAGS: "", CTEST_FLAGS: --output-on-failure -E checkperf }
    steps: [ cmake_test ]
-  gcc-avx-threaded:
-    description: Build, run tests and check performance on GCC 7 and AVX 2 with threads
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_ENABLE_THREADS=ON }
+  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: --output-on-failure -E checkperf }
    steps: [ cmake_test ]

-  clang-avx-unthreaded:
-    description: Build, run tests and check performance on Clang 6 and AVX 2 *without* threads
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
-    steps: [ init_clang6, cmake_test ]
-  clang-avx-threaded:
-    description: Build, run tests and check performance on Clang 6 and AVX 2 with threads
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_ENABLE_THREADS=ON }
-    steps: [ init_clang6, cmake_test ]
+  # dynamic
+  dynamic-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake dynamic build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+  dynamic-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake dynamic build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF }
+    steps: [ cmake_test, cmake_install_test ]

-  gcc9-avx:
-    description: Build, run tests and check performance on GCC 9 and AVX 2
-    executor: gcc9
-    steps: [ make_test_strict ]
-  gcc8-avx:
-    description: Build, run tests and check performance on GCC 8 and AVX 2
-    executor: gcc9
-    steps: [ make_test_strict ]
-  gcc-avx:
-    description: Build, run tests and check performance on GCC 7 and AVX 2
-    executor: gcc7
-    steps: [ make_test ]
-  gcc-avx-dynamic:
-    description: Build, run tests and check performance on GCC 7 and AVX 2 with a cmake dynamic build
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF }
-    steps: [ cmake_test ]
-  gcc-avx-static:
-    description: Build, run tests and check performance on GCC 7 and AVX 2 with a cmake static build
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=ON }
-    steps: [ cmake_test ]
-  gcc-avx-google-benchmarks:
-    description: Build, run tests and check performance on GCC 7 with google benchmarks enabled
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON }
-    steps: [ cmake_test ]
-  gcc-avx-sanitize:
-    description: Build, run tests and check performance on GCC 7 and AVX 2 with a cmake sanitize build
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON }
-    steps: [ cmake_simple_test ]
+  # unthreaded
+  unthreaded-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 *without* threads
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+  unthreaded-clang10:
+    description: Build and run tests on Clang 10 and AVX 2 *without* threads
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
+    steps: [ cmake_test, cmake_install_test ]

-  gcc-sse:
-    description: Build, run tests and check performance on GCC 7 and SSE 4.2
-    executor: gcc7
-    environment: { ARCHFLAGS: -march=nehalem }
-    steps: [ make_test ]
-  gcc-sse-dynamic:
-    description: Build, run tests and check performance on GCC 7 and SSE 4.2 with a cmake dynamic build
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF }
-    steps: [ cmake_test ]
-  gcc-sse-static:
-    description: Build, run tests and check performance on GCC 7 and SSE 4.2 with a cmake static build
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=ON }
-    steps: [ cmake_test ]
-  gcc-sse-sanitize:
-    description: Build, run tests and check performance on GCC 7 and SSE 4.2 with a cmake sanitize build
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON }
-    steps: [ cmake_simple_test ]
+  # noexcept
+  noexcept-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with exceptions off
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+  noexcept-clang10:
+    description: Build and run tests on Clang 10 and AVX 2 with exceptions off
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF }
+    steps: [ cmake_test, cmake_install_test ]

-  clang-avx:
-    description: Build, run tests and check performance on clang 6 and AVX 2
-    executor: clang6
-    steps: [ init_clang6, make_test ]
-  clang-avx-dynamic:
-    description: Build, run tests and check performance on clang 6 and AVX 2 with a cmake dynamic build
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF }
-    steps: [ init_clang6, cmake_test ]
-  clang-avx-static:
-    description: Build, run tests and check performance on clang 6 and AVX 2 with a cmake static build
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=ON }
-    steps: [ init_clang6, cmake_test ]
-  clang-avx-google-benchmarks:
-    description: Build, run tests and check performance on clang 6 with google benchmarks enabled
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON }
-    steps: [ init_clang6, cmake_test ]
-  clang-avx-sanitize:
-    description: Build, run tests and check performance on clang 6 and AVX 2 with a cmake sanitize build
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON }
-    steps: [ init_clang6, cmake_simple_test ]
+  #
+  # Misc.
+  #

-  clang-sse:
-    description: Build, run tests and check performance on Clang 6 and SSE 4.2
-    executor: clang6
-    environment: { ARCHFLAGS: -march=nehalem }
-    steps: [ init_clang6, make_test ]
-  clang-sse-dynamic:
-    description: Build, run tests and check performance on Clang 6 and SSE 4.2 with a cmake dynamic build
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF }
-    steps: [ init_clang6, cmake_test ]
-  clang-sse-static:
-    description: Build, run tests and check performance on Clang 6 and SSE 4.2 with a cmake static build
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=ON }
-    steps: [ init_clang6, cmake_test ]
-  clang-sse-sanitize:
-    description: Build, run tests and check performance on Clang 6 and SSE 4.2 with a cmake sanitize build
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON }
-    steps: [ init_clang6, cmake_simple_test ]
+  # make (test and checkperf)
+  arch-haswell-gcc10:
+    description: Build, run tests and check performance on GCC 10 with -march=haswell
+    executor: gcc10
+    environment: { CXXFLAGS: -march=haswell }
+    steps: [ cmake_test ]
+  arch-nehalem-gcc10:
+    description: Build, run tests and check performance on GCC 10 with -march=nehalem
+    executor: gcc10
+    environment: { CXXFLAGS: -march=nehalem }
+    steps: [ cmake_test ]
+  sanitize-haswell-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
+    executor: gcc10
+    environment: {  CXXFLAGS: -march=haswell, CMAKE_FLAGS: -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
  build_and_test:
    jobs:
-      - gcc9-avx
-      - gcc8-avx
-      - gcc-avx
-      - gcc-avx-dynamic
-      - gcc-avx-static
-      - gcc-avx-google-benchmarks
-      - gcc-avx-sanitize
-      - gcc-sse
-      - gcc-sse-dynamic
-      - gcc-sse-static
-      - gcc-sse-sanitize
-      - clang-avx
-      - clang-avx-dynamic
-      - clang-avx-static
-      - clang-avx-google-benchmarks
-      - clang-avx-sanitize
-      - clang-sse
-      - clang-sse-dynamic
-      - clang-sse-static
-      - clang-sse-sanitize
-      - gcc-avx-threaded
-      - gcc-avx-unthreaded
-      - clang-avx-threaded
-      - clang-avx-unthreaded
+      # full multi-implementation tests
+      #- gcc7 tested on GitHub actions
+      - gcc10 # do not delete this as it tests our performance
+      - clang6
+      #- clang10 # this gets tested a lot below
+
+      # libc++
+      - libcpp-clang10
+
+      # full single-implementation tests
+      - sanitize-gcc10
+      - sanitize-clang10
+      - dynamic-gcc10
+      - dynamic-clang10
+      - unthreaded-gcc10
+      - unthreaded-clang10
+
+      # no exceptions
+      - noexcept-gcc10
+      - noexcept-clang10
+
+      # quicker make single-implementation tests
+      - arch-haswell-gcc10
+      - arch-nehalem-gcc10
+
+
+      # sanitized single-implementation tests
+      - sanitize-haswell-gcc10
+      - sanitize-haswell-clang10
+
+      # testing "just the library"
+      - justlib-gcc10

      # TODO add windows: https://circleci.com/docs/2.0/configuration-reference/#windows
-
@@ -0,0 +1,21 @@
+task:
+  timeout_in: 120m
+  freebsd_instance:
+    matrix:
+      - image_family: freebsd-13-0-snap
+
+  env:
+    ASSUME_ALWAYS_YES: YES
+  setup_script:
+    - pkg update -f
+    - pkg install bash
+    - pkg install cmake
+    - pkg install git
+  build_script:
+    - mkdir build
+    - cd build
+    - cmake -DSIMDJSON_BASH=OFF  -DSIMDJSON_GIT=OFF ..
+    - make
+  test_script:
+    - cd build
+    - ctest --output-on-failure -E checkperf
@@ -1,7 +1,7 @@
 *
 !.git
 !Makefile
-!amalgamation.sh
+!amalgamate.sh
 !benchmark
 !dependencies
 !include
@@ -1,207 +1,409 @@
 kind: pipeline
-name: x64-quicktests-libc
-
-platform:
-  os: linux
-  arch: amd64
-
+name: i386-gcc # we do not support 32-bit systems, but we run tests
+platform: { os: linux, arch: amd64 }
 steps:
- name: quicktests
-  image: conanio/clang8
+- name: Build and Test
+  image: i386/ubuntu
+  environment:
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    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
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS 
+---
+kind: pipeline
+name: i386-clang # we do not support 32-bit systems, but we run tests
+platform: { os: linux, arch: amd64 }
+steps:
+- name: Build and Test
+  image: i386/ubuntu
+  environment:
+    CC: clang-6.0
+    CXX: clang++-6.0
+    BUILD_FLAGS: -- -j
+    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
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS 
+---
+kind: pipeline
+name: gcc9
+platform: { os: linux, arch: amd64 }
+steps:
+- name: Build and Test
+  image: gcc:9
+  environment:
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_IMPLEMENTATION=haswell;westmere;fallback
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
+  commands:
+    - apt-get update -qq
+    - apt-get install -y cmake
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - 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
+    - ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
+---
+kind: pipeline
+name: clang6
+platform: { os: linux, arch: amd64 }
+steps:
+- name: Build and Test
+  image: conanio/clang60
  user: root
-  commands: [ EXTRAFLAGS=-stdlib=libc++ make quicktests ]
+  environment:
+    CC: clang-6.0
+    CXX: clang++-6.0
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_IMPLEMENTATION=haswell;westmere;fallback
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
+  commands:
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - 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
+    - ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
 ---
 kind: pipeline
-name: x64-quicktests
-
-platform:
-  os: linux
-  arch: amd64
-
+name: dynamic-gcc9
+platform: { os: linux, arch: amd64 }
 steps:
- name: quicktests
-  image: gcc:8
-  commands: [ make quicktests ]
+- name: Build and Test
+  image: gcc:9
+  environment:
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
+  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: x64-checkperf
-
-platform:
-  os: linux
-  arch: amd64
-
+name: dynamic-clang9
+platform: { os: linux, arch: amd64 }
 steps:
- name: checkperf
+- name: Build and Test
+  image: conanio/clang9
+  user: root
+  environment:
+    CC: clang-9
+    CXX: clang++-9
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
+    BUILD_FLAGS: -- -j
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
+  commands:
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
+---
+kind: pipeline
+name: sanitize-gcc9
+platform: { os: linux, arch: amd64 }
+steps:
+- name: Build and Test
+  image: gcc:9
+  environment:
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_IMPLEMENTATION=haswell;westmere;fallback
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
+  commands:
+    - apt-get update -qq
+    - apt-get install -y cmake
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L acceptance -LE per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=haswell ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=westmere ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=fallback ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
+---
+kind: pipeline
+name: sanitize-clang9
+platform: { os: linux, arch: amd64 }
+steps:
+- name: Build and Test
+  image: conanio/clang9
+  user: root
+  environment:
+    CC: clang-9
+    CXX: clang++-9
+    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON -DSIMDJSON_IMPLEMENTATION=haswell;westmere;fallback
+    BUILD_FLAGS: -- -j
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
+  commands:
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L acceptance -LE per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=haswell ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=westmere ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=fallback ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
+---
+kind: pipeline
+name: arm64-gcc8
+platform: { os: linux, arch: arm64 }
+steps:
+- name: Build and Test
  image: gcc:8
  environment:
-    CHECKPERF_REPOSITORY: https://github.com/lemire/simdjson
-  commands: [ sed '/^$/Q' /proc/cpuinfo, make checkperf ]
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_IMPLEMENTATION=arm64;fallback
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
+  commands:
+    - apt-get update -qq
+    - apt-get install -y cmake
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS -L acceptance -LE per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=arm64 ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation
+    - ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
 ---
 kind: pipeline
-name: x64-build
-
-platform:
-  os: linux
-  arch: amd64
-
+name: arm64-clang6
+platform: { os: linux, arch: arm64 }
 steps:
- name: build
-  image: gcc:8
-  commands: [ make, make amalgamate ]
+- name: Build and Test
+  image: ubuntu:18.04
+  environment:
+    CC: clang-6.0
+    CXX: clang++-6.0
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
+    BUILD_FLAGS: -- -j
+    CTEST_FLAGS: -j4 --output-on-failure  -E checkperf
+  commands:
+    - apt-get update -qq
+    - apt-get install -y clang cmake git
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
 ---
 kind: pipeline
-name: x64-slowtests
-
-platform:
-  os: linux
-  arch: amd64
-
+name: arm64-dynamic-gcc8
+platform: { os: linux, arch: arm64 }
 steps:
- name: slowtests
-  image: gcc:8
-  commands: [ make slowtests ]
---
-kind: pipeline
-name: x64-noexceptions-quicktests
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
- name: quicktests
+- name: Build and Test
  image: gcc:8
  environment:
-    EXTRA_FLAGS: -fno-exceptions
-  commands: [ make quicktests ]
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
+  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: x64-noexceptions-build
-
-platform:
-  os: linux
-  arch: amd64
-
+name: arm64-dynamic-clang6
+platform: { os: linux, arch: arm64 }
 steps:
- name: build
+- name: Build and Test
+  image: ubuntu:18.04
+  environment:
+    CC: clang-6.0
+    CXX: clang++-6.0
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
+    BUILD_FLAGS: -- -j
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
+  commands:
+    - apt-get update -qq
+    - apt-get install -y clang cmake git
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
+---
+kind: pipeline
+name: arm64-sanitize-gcc8
+platform: { os: linux, arch: arm64 }
+steps:
+- name: Build and Test
  image: gcc:8
  environment:
-    EXTRA_FLAGS: -fno-exceptions
-  commands: [ make, make amalgamate ]
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_IMPLEMENTATION=arm64;fallback
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
+    CC: gcc
+    CXX: g++
+  commands:
+    - apt-get update -qq
+    - apt-get install -y cmake libstdc++6
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L acceptance -LE per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=arm64 ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=fallback ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
 ---
 kind: pipeline
-name: x64-noexceptions-slowtests
-
-platform:
-  os: linux
-  arch: amd64
-
+name: arm64-sanitize-clang6
+platform: { os: linux, arch: arm64 }
 steps:
- name: slowtests
-  image: gcc:8
+- name: Build and Test
+  image: ubuntu:18.04
  environment:
-    EXTRA_FLAGS: -fno-exceptions
-  commands: [ make slowtests ]
+    CC: clang-6.0
+    CXX: clang++-6.0
+    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
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L acceptance -LE per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=arm64 ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=fallback ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
 ---
 kind: pipeline
-name: arm64-quicktests
-
-platform:
-  os: linux
-  arch: arm64
-
+name: ninja-clang9
+platform: { os: linux, arch: amd64 }
 steps:
- name: quicktests
-  image: gcc:8
-  commands: [ make quicktests ]
---
-kind: pipeline
-name: arm64-checkperf
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
- name: checkperf
-  image: gcc:8
+- name: Build and Test
+  image: conanio/clang9
+  user: root
  environment:
-    CHECKPERF_REPOSITORY: https://github.com/lemire/simdjson
-  commands: [ cat /proc/cpuinfo, make checkperf ]
+    CC: clang-9
+    CXX: clang++-9
+    BUILD_FLAGS: -- -j 4
+    CMAKE_FLAGS: -GNinja -DSIMDJSON_BUILD_STATIC=ON
+    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: arm64-build
-
-platform:
-  os: linux
-  arch: arm64
-
+name: libcpp-clang9
+platform: { os: linux, arch: amd64 }
 steps:
- name: build
-  image: gcc:8
-  commands: [ make, make amalgamate ]
---
-kind: pipeline
-name: arm64-slowtests
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
- name: slowtests
-  image: gcc:8
-  commands: [ make slowtests ]
---
-kind: pipeline
-name: x64-amalgamated-build
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
- name: build
-  image: gcc:8
+- name: Build and Test
+  image: conanio/clang9
+  user: root
  environment:
-    SIMDJSON_TEST_AMALGAMATED_HEADERS: 1
-  commands: [ make amalgamate, make ]
+    CC: clang-9
+    CXX: clang++-9
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
+    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: x64-amalgamated-quicktests
-
-platform:
-  os: linux
-  arch: amd64
-
+name: noexceptions-gcc9
+platform: { os: linux, arch: amd64 }
 steps:
- name: quicktests
-  image: gcc:8
+- name: Build and Test
+  image: gcc:9
  environment:
-    SIMDJSON_TEST_AMALGAMATED_HEADERS: 1
-  commands: [ make amalgamate, make quicktests ]
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF
+    CTEST_FLAGS: -j4 --output-on-failure -E checkperf
+  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: x64-amalgamated-slowtests
-
-platform:
-  os: linux
-  arch: amd64
-
+name: arm64-fuzz
+platform: { os: linux, arch: arm64 }
 steps:
- name: slowtests
-  image: gcc:8
+- name: Build and run fuzzers shortly
+  image: ubuntu:20.04
  environment:
-    SIMDJSON_TEST_AMALGAMATED_HEADERS: 1
-  commands: [ make amalgamate, make slowtests ]
+    CC: clang
+    CXX: clang++
+    DEBIAN_FRONTEND: noninteractive
+    ASAN_OPTIONS: detect_leaks=0
+  commands:
+    - apt-get update -qq
+    - 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
-
+platform: { os: linux, arch: amd64 }
 steps:
 - name: Build and Test
  image: ubuntu:18.04
@@ -209,350 +411,3 @@ steps:
    - apt-get update -y
    - apt-get install -y python clang-format
    - ./style/run-clang-format.py -r include/ benchmark/ src/ tests/
---
-kind: pipeline
-name: amd64_clang_cmake_dynamic
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
-  commands:
-    - apt-get update -qq
-    - apt-get install -y clang make cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
---
-  kind: pipeline
-  name: amd64_clang_cmake_no_exceptions
-  
-  platform:
-    os: linux
-    arch: amd64
-  
-  steps:
-  - name: Build and Test
-    image: ubuntu:18.04
-    environment:
-      CC: clang
-      CXX: clang++
-      CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
-    commands:
-      - apt-get update -qq
-      - apt-get install -y clang make cmake
-      - $CC --version
-      - mkdir build && cd build
-      - cmake $CMAKE_FLAGS ..
-      - make -j
-      - ctest --output-on-failure
-kind: pipeline
-name: amd64_clang_cmake_static
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y clang make cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
---
-kind: pipeline
-name: amd64_gcc_cmake_static
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake 
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
---
-kind: pipeline
-name: amd64_gcc_cmake_dynamic
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
---
-kind: pipeline
-name: arm64_clang_cmake_dynamic
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
-  commands:
-    - apt-get update -qq
-    - apt-get install -y clang make cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
---
-kind: pipeline
-name: arm64_gcc_cmake_dynamic
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
---
-kind: pipeline
-name: arm64_clang_cmake_static
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y clang make cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
---
-kind: pipeline
-name: arm64_gcc_cmake_static
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
-
---
-kind: pipeline
-name: arm64_clang_cmake_sanitize
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y clang make cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ASAN_OPTIONS="detect_leaks=0" ctest --output-on-failure
---
-kind: pipeline
-name: arm64_gcc_cmake_sanitize
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ASAN_OPTIONS="detect_leaks=0" ctest --output-on-failure
-
---
-kind: pipeline
-name: amd64_clang_cmake_sanitize
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON
-  commands:
-    - apt-get update -y
-    - apt-get install -y make $CC g++ cmake 
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ASAN_OPTIONS="detect_leaks=0" ctest --output-on-failure
---
-kind: pipeline
-name: amd64_gcc_cmake_sanitize
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ASAN_OPTIONS="detect_leaks=0" ctest --output-on-failure
-
---
-kind: pipeline
-name: amd64_clang_cmake_sanitize_noavx
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON -DSIMDJSON_IMPLEMENTATION_HASWELL=OFF
-  commands:
-    - apt-get update -qq
-    - apt-get install -y clang make cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ASAN_OPTIONS="detect_leaks=0" ctest --output-on-failure
---
-kind: pipeline
-name: amd64_gcc_cmake_sanitize_noavx
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON -DSIMDJSON_IMPLEMENTATION_HASWELL=OFF
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ASAN_OPTIONS="detect_leaks=0" ctest --output-on-failure
@@ -80,15 +80,15 @@
 .gitignore     export-ignore

 # Sources
-*.c     text diff=c
-*.cc    text diff=cpp
-*.cxx   text diff=cpp
-*.cpp   text diff=cpp
-*.c++   text diff=cpp
-*.hpp   text diff=cpp
-*.h     text diff=c
-*.h++   text diff=cpp
-*.hh    text diff=cpp
+*.c     text eol=lf diff=c
+*.cc    text eol=lf diff=cpp
+*.cxx   text eol=lf diff=cpp
+*.cpp   text eol=lf diff=cpp
+*.c++   text eol=lf diff=cpp
+*.hpp   text eol=lf diff=cpp
+*.h     text eol=lf diff=c
+*.h++   text eol=lf diff=cpp
+*.hh    text eol=lf diff=cpp

 # Compiled Object files
 *.slo   binary
@@ -0,0 +1,41 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug (unverified)
+assignees: ''
+
+---
+
+Before submitting an issue, please ensure that you have read the documentation:
+
+* Basics is an overview of how to use simdjson and its APIs: 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. 
+
+**To Reproduce**
+Steps to reproduce the behaviour: provide a code sample if possible.
+
+If we cannot reproduce the issue, then we cannot address it.
+
+Note that a stack trace from your own program is not enough.
+
+**Configuration (please complete the following information if relevant):**
+ - OS: [e.g. Ubuntu 16.04.6 LTS]
+ - 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. 
+
+**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 
+* 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: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+Before submitting an issue, please ensure that you have read the documentation:
+
+* Basics is an overview of how to use simdjson and its APIs: 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.
+
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+ Please provide a clear rationale for the feature. Be advised that simdjson is a community-based project: you should consider providing help.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+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 
+* 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,32 @@
+---
+name: Standard issue template
+about: Issue
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+Before submitting an issue, please ensure that you have read the documentation:
+
+* Basics is an overview of how to use simdjson and its APIs: 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.
+
+Is your issue:
+
+1. A bug report? If so, please point at a reproducible test. Indicate whether you are willing or able to provide a bug fix as a pull request.
+
+2. A build issue? If so, provide all possible details regarding your system configuration. If we cannot reproduce your issue, we cannot fix it.
+
+3. A feature request? Please provide a clear rationale for the feature. Be advised that simdjson is a community-based project: you should consider providing help.
+
+4. A documentation issue? Can you suggest an improvement?
+
+
+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,27 @@
+name: Alpine Linux
+'on':
+  - push
+  - pull_request
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - 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"
@@ -1,11 +1,9 @@
-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:
  schedule:
    - cron: 23 */8 * * *
@@ -14,8 +12,14 @@ jobs:
  build:    
    runs-on: ubuntu-latest
    env:
-      allfuzzers: parser dump dump_raw_tape print_json
-      artifactsprefix: -artifact_prefix=fuzzfailure/
+      # fuzzers that use the default implementation
+      defaultimplfuzzers: atpointer dump dump_raw_tape element minify  parser print_json
+      # fuzzers that loop over the implementations themselves
+      implfuzzers: implementations minifyimpl utf8
+      implementations: haswell westmere fallback
+      UBSAN_OPTIONS: halt_on_error=1
+      MAXLEN: -max_len=4000
+
    steps:
    - name: Install packages necessary for building
      run: |
@@ -23,105 +27,126 @@ 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 8
+        sudo ./llvm.sh 10

    - uses: actions/checkout@v1
+
    - 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
+
+    - 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-fast8/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-noavx8/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-noavx8/fuzz/fuzz_$fuzzer   out/$fuzzer -max_total_time=10 -reload=0 $artifactsprefix
-          echo build-ossfuzz-msan-withavx8/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/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/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-fast8/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
+
@@ -0,0 +1,53 @@
+name: MinGW32-CI
+
+on: [push, pull_request]
+
+# Important: scoop will either install 32-bit GCC or 64-bit GCC, not both.
+
+# It is important to build static libraries because cmake is not smart enough under Windows/mingw to take care of the path. So
+# with a dynamic library, you could get failures due to the fact that the EXE can't find its DLL.
+
+jobs:
+  ci:
+    name: windows-gcc
+    runs-on: windows-2016
+
+    env:
+      CMAKE_GENERATOR: Ninja # This is critical, try ' cmake  -GNinja-DSIMDJSON_BUILD_STATIC=ON .. ' if using the command line
+      CC: gcc
+      CXX: g++
+
+    steps: # To reproduce what is below, start a powershell with administrative rights, using scoop *is* a good idea
+      - uses: actions/checkout@v2
+
+      - uses: actions/cache@v2 # we cache the scoop setup with 32-bit GCC
+        id: cache
+        with:
+          path: |
+            C:\ProgramData\scoop
+          key: scoop32 # static key: should be good forever
+      - name: Setup Windows # This should almost never run if the cache works.
+        if: steps.cache.outputs.cache-hit != 'true'
+        shell: powershell
+        run: |
+          Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://get.scoop.sh')
+          scoop install sudo --global
+          sudo scoop install git --global 
+          sudo scoop install ninja --global
+          sudo scoop install cmake --global
+          sudo scoop install gcc --arch 32bit --global
+          $env:path
+          Write-Host 'Everything has been installed, you are good!'
+      - name: Build and Test 32-bit x86
+        shell: powershell
+        run: |
+          $ENV:PATH="C:\ProgramData\scoop\shims;C:\ProgramData\scoop\apps\gcc\current\bin;C:\ProgramData\scoop\apps\ninja\current;$ENV:PATH"
+          g++ --version
+          cmake --version
+          ninja --version
+          git --version
+          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 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
@@ -0,0 +1,59 @@
+name: MinGW64-CI
+
+on: [push, pull_request]
+
+# Important: scoop will either install 32-bit GCC or 64-bit GCC, not both.
+
+# It is important to build static libraries because cmake is not smart enough under Windows/mingw to take care of the path. So
+# with a dynamic library, you could get failures due to the fact that the EXE can't find its DLL.
+
+jobs:
+  ci:
+    name: windows-gcc
+    runs-on: windows-2016
+
+    env:
+      CMAKE_GENERATOR: Ninja # This is critical, try ' cmake  -GNinja-DSIMDJSON_BUILD_STATIC=ON .. ' if using the command line
+      CC: gcc
+      CXX: g++
+
+    steps: # To reproduce what is below, start a powershell with administrative rights, using scoop *is* a good idea
+      - uses: actions/checkout@v2
+
+      - uses: actions/cache@v2 # we cache the scoop setup with 64-bit GCC
+        id: cache
+        with:
+          path: |
+            C:\ProgramData\scoop
+          key: scoop64 # static key: should be good forever
+      - name: Setup Windows # This should almost never run if the cache works.
+        if: steps.cache.outputs.cache-hit != 'true'
+        shell: powershell
+        run: |
+          Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://get.scoop.sh')
+          scoop install sudo --global
+          sudo scoop install git --global
+          sudo scoop install ninja --global
+          sudo scoop install cmake --global
+          sudo scoop install gcc --arch 64bit --global
+          $env:path
+          Write-Host 'Everything has been installed, you are good!'
+      - name: Build and Test 64-bit x64
+        shell: powershell
+        run: |
+          $ENV:PATH="C:\ProgramData\scoop\shims;C:\ProgramData\scoop\apps\gcc\current\bin;C:\ProgramData\scoop\apps\ninja\current;$ENV:PATH"
+          g++ --version
+          cmake --version
+          ninja --version
+          git --version
+          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 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 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
@@ -0,0 +1,44 @@
+name: MSYS2-CI
+
+on: [push, pull_request]
+
+jobs:
+  windows-mingw:
+    name: ${{ matrix.msystem }}
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - msystem: "MINGW64"
+            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
+            type: Release
+          - msystem: "MINGW32"
+            install: mingw-w64-i686-cmake mingw-w64-i686-ninja mingw-w64-i686-gcc
+            type: Release
+          - msystem: "MINGW64"
+            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
+            type: Debug
+          - msystem: "MINGW32"
+            install: mingw-w64-i686-cmake mingw-w64-i686-ninja mingw-w64-i686-gcc
+            type: Debug
+    env:
+      CMAKE_GENERATOR: Ninja
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: msys2/setup-msys2@v2
+        with:
+          update: true
+          msystem: ${{ matrix.msystem }}
+          install: ${{ matrix.install }}
+      - name: Build and Test
+        run: |
+          mkdir build
+          cd build
+          cmake -DCMAKE_BUILD_TYPE=${{ matrix.type }} -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_DO_NOT_USE_THREADS_NO_MATTER_WHAT=ON ..
+          cmake --build . --verbose
+          ctest -j4 --output-on-failure -E checkperf
@@ -0,0 +1,21 @@
+name: Performance check on Ubuntu 18.04 CI (GCC 7)
+
+on: [push, pull_request]
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup cmake
+        uses: jwlawson/actions-setup-cmake@v1.0
+        with:
+          cmake-version: '3.9.x'
+      - 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,22 @@
+name: Ubuntu 18.04 CI (GCC 7)
+
+on: [push, pull_request]
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup cmake
+        uses: jwlawson/actions-setup-cmake@v1.0
+        with:
+          cmake-version: '3.9.x'
+      - 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 -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,20 @@
+name: Performance check on Ubuntu 20.04 CI (GCC 9)
+
+on: [push, pull_request]
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup cmake
+        uses: jwlawson/actions-setup-cmake@v1.0
+        with:
+          cmake-version: '3.9.x'
+      - 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,22 @@
+name: Ubuntu 20.04 CI (GCC 9)
+
+on: [push, pull_request]
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup cmake
+        uses: jwlawson/actions-setup-cmake@v1.0
+        with:
+          cmake-version: '3.9.x'
+      - 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 -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: VS16-CI
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    name: windows-vs16
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: 'Run CMake with VS16'
+      uses: lukka/run-cmake@v2
+      with:
+        cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+        cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
+        buildDirectory: "${{ github.workspace }}/../../_temp/windows"
+        cmakeBuildType: Release   
+        buildWithCMake: true
+        cmakeGenerator: VS16Win64 
+        cmakeAppendedArgs: -DSIMDJSON_COMPETITION=OFF
+        buildWithCMakeArgs: --config Release  
+        
+    - name: 'Run CTest'
+      run: ctest -C Release  -E checkperf  --output-on-failure 
+      working-directory: "${{ github.workspace }}/../../_temp/windows"
+  
@@ -0,0 +1,25 @@
+name: VS16-CLANG-CI
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    name: windows-vs16
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: 'Run CMake with VS16'
+      uses: lukka/run-cmake@v2
+      with:
+        cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+        cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
+        buildDirectory: "${{ github.workspace }}/../../_temp/windows"
+        cmakeBuildType: Release   
+        buildWithCMake: true
+        cmakeGenerator: VS16Win64 
+        cmakeAppendedArgs:  -T ClangCL -DSIMDJSON_COMPETITION=OFF  -DSIMDJSON_BUILD_STATIC=ON
+        buildWithCMakeArgs: --config Release  
+        
+    - name: 'Run CTest'
+      run: ctest -C Release -E checkperf  --output-on-failure 
+      working-directory: "${{ github.workspace }}/../../_temp/windows"
@@ -0,0 +1,26 @@
+name: VS16-Ninja-CI
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    name: windows-vs16
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: 'Run CMake with VS16'
+      uses: lukka/run-cmake@v2
+      with:
+        cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+        cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
+        buildDirectory: "${{ github.workspace }}/../../_temp/windows"
+        cmakeBuildType: Release   
+        buildWithCMake: true
+        cmakeGenerator: VS16Win64 
+        cmakeAppendedArgs:  -G Ninja -DSIMDJSON_COMPETITION=OFF   -DSIMDJSON_BUILD_STATIC=ON
+        buildWithCMakeArgs: --config Release  
+        
+    - name: 'Run CTest'
+      run: ctest -C Release  -E checkperf  --output-on-failure 
+      working-directory: "${{ github.workspace }}/../../_temp/windows"
+  
@@ -1,8 +1,3 @@
-visual_studio
-
-/benchbranch/
-/submodules/
-
 # eclipse project files
 .cproject
 .project
@@ -52,85 +47,6 @@ gens
 libs
 objs

-# Build outputs (TODO build to a subdir so we can exclude that instead)
-/allparserscheckfile
-/allparsingcompetition
-/basictests
-/benchfeatures
-/benchmark/bench_dom_api
-/benchmark/bench_parse_call
-/benchmark/get_corpus_benchmark
-/benchmark/parse
-/benchmark/parse_stream
-/benchmark/perfdiff
-/benchmark/statisticalmodel
-/build/
-/build-ossfuzz-*/
-/build-plain-*/
-/corpus.zip
-/distinctuseridcompetition
-/errortests
-/examples/quickstart/quickstart
-/examples/quickstart/simdjson.cpp
-/examples/quickstart/simdjson.h
-/examples/quickstart/twitter.json
-/fuzz/fuzz_dump
-/fuzz/fuzz_dump_raw_tape
-/fuzz/fuzz_parser
-/fuzz/fuzz_print_json
-/get_corpus_benchmark
-/json2json
-/jsoncheck
-/jsoncheck_westmere
-/jsoncheck_fallback
-/jsonpointer
-/jsonstats
-/integer_tests
-/libsimdjson.so*
-/minifiercompetition
-/minify
-/numberparsingcheck
-/ossfuzz-out
-/out
-/parse
-/parse_many_test
-/parse_nonumberparsing
-/parse_nostringparsing
-/parse_noutf8validation
-/parse_stream
-/parseandstatcompetition
-/parsingcompetition
-/perfdiff
-/pointercheck
-/readme_examples
-/readme_examples_noexceptions
-/statisticalmodel
-/stringparsingcheck
-/submodules
-/ujdecode.o
-/amalgamation_demo.cpp
-/simdjson.cpp
-/simdjson.h
-/singleheader/amalgamation_demo
-/singleheader/demo
-/tests/basictests
-/tests/errortests
-/tests/jsoncheck
-/tests/pointercheck
-/tests/integer_tests
-/tests/parse_many_test
-/tests/readme_examples
-/tests/readme_examples_noexceptions
-/tools/json2json
-/tools/jsonstats
-/tools/minify
-
-# Don't check in generated API docs
-/doc/api
-
-# Don't check in generated examples
-/jsonexamples/generated
-
 # C++ ignore from https://github.com/github/gitignore/blob/master/C%2B%2B.gitignore

 # Prerequisites
@@ -167,23 +83,16 @@ objs
 *.app


-### https://raw.github.com/github/gitignore/e92f8db7a027af8cc25da2dc0758317e39697684/CMake.gitignore
-
-CMakeLists.txt.user
-CMakeCache.txt
-CMakeFiles
-CMakeScripts
-Testing
-Makefile
-cmake_install.cmake
-install_manifest.txt
-compile_commands.json
-CTestTestfile.cmake
-_deps
-
 # CMake files that may be specific to our installation
-/CPackConfig.cmake
-/CPackSourceConfig.cmake
-# We check in a custom version of root Makefile that is not generated by CMake
-!/Makefile

+# Build outputs
+/build*/
+/visual_studio/
+
+# Fuzzer outputs generated by instructions in fuzz/Fuzzing.md
+/corpus.zip
+/ossfuzz-out/
+/out/
+
+# Generated docs
+/doc/api
@@ -31,3 +31,12 @@
 [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
+[submodule "dependencies/boost.json"]
+	path = dependencies/boost.json
+	url = https://github.com/CPPAlliance/json.git
+[submodule "dependencies/yyjson"]
+	path = dependencies/yyjson
+	url = https://github.com/ibireme/yyjson.git
@@ -1,3 +1,4 @@
-# List of authors for copyright purposes
+# List of authors for copyright purposes, in no particular order
 Daniel Lemire
 Geoff Langdale
+John Keiser
@@ -1,90 +1,76 @@
 cmake_minimum_required(VERSION 3.9) # CMP0069 NEW

-if (NOT CMAKE_BUILD_TYPE)
-  message(STATUS "No build type selected, default to Release")
-  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
-endif()
-
 project(simdjson
  DESCRIPTION "Parsing gigabytes of JSON per second"
-  LANGUAGES CXX
+  LANGUAGES CXX C
 )

-# LTO seems to create all sorts of fun problems. Let us
-# disable temporarily.
-#include(CheckIPOSupported)
-#check_ipo_supported(RESULT ltoresult)
-#if(ltoresult)
-#  set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
-#endif()
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_MACOSX_RPATH OFF)
-set(CMAKE_THREAD_PREFER_PTHREAD ON)
-set(THREADS_PREFER_PTHREAD_FLAG ON)
-
-set(SIMDJSON_LIB_NAME simdjson)
 set(PROJECT_VERSION_MAJOR 0)
-set(PROJECT_VERSION_MINOR 3)
-set(PROJECT_VERSION_PATCH 1)
-set(SIMDJSON_LIB_VERSION "0.3.1" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "1" CACHE STRING "simdjson library soversion")
+set(PROJECT_VERSION_MINOR 6)
+set(PROJECT_VERSION_PATCH 0)
+set(SIMDJSON_SEMANTIC_VERSION "0.6.0" CACHE STRING "simdjson semantic version")
+set(SIMDJSON_LIB_VERSION "4.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "4" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_GITHUB_REPOSITORY https://github.com/simdjson/simdjson)

-option(SIMDJSON_IMPLEMENTATION_HASWELL "Include the haswell implementation" ON)
-option(SIMDJSON_IMPLEMENTATION_WESTMERE "Include the westmere implementation" ON)
-option(SIMDJSON_IMPLEMENTATION_ARM64 "Include the arm64 implementation" ON)
-option(SIMDJSON_IMPLEMENTATION_FALLBACK "Include the fallback implementation" ON)
-if(NOT MSVC)
-  option(SIMDJSON_BUILD_STATIC "Build a static library" OFF) # turning it on disables the production of a dynamic library
-else()
-  option(SIMDJSON_BUILD_STATIC "Build a static library" ON) # turning it on disables the production of a dynamic library
-endif()
-option(SIMDJSON_SANITIZE "Sanitize addresses" OFF)
-option(SIMDJSON_GOOGLE_BENCHMARKS "compile the Google Benchmark benchmarks" OFF)
-option(SIMDJSON_ENABLE_THREADS "enable threaded operation" ON)
-option(SIMDJSON_EXCEPTIONS "Enable simdjson's exception-throwing interface" ON)
+include(GNUInstallDirs)
+include(cmake/simdjson-flags.cmake)
+include(cmake/simdjson-user-cmakecache.cmake)

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

-find_package(CTargets)
-find_package(Options)

-# We used to have install(DIRECTORY include/${SIMDJSON_LIB_NAME} DESTINATION include)
-# alone.
-# However, this fails because we also need the root level simdjson.h file.
-install(DIRECTORY include/${SIMDJSON_LIB_NAME} DESTINATION include)
-install(FILES include/${SIMDJSON_LIB_NAME}.h DESTINATION include)
-set (TEST_DATA_DIR "${CMAKE_CURRENT_SOURCE_DIR}/jsonchecker/")
-set (BENCHMARK_DATA_DIR "${CMAKE_CURRENT_SOURCE_DIR}/jsonexamples/")
-add_definitions(-DSIMDJSON_TEST_DATA_DIR="${TEST_DATA_DIR}")
-add_definitions(-DSIMDJSON_BENCHMARK_DATA_DIR="${TEST_DATA_DIR}")
-enable_testing()
-include(include/CMakeLists.txt)
+if(SIMDJSON_JUST_LIBRARY)
+  message( STATUS "Building just the library, omitting all tests, tools and benchmarks." )
+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(SIMDJSON_JUST_LIBRARY)
+
+# Create the top level simdjson library (must be done at this level to use both src/ and include/
+# directories) and tools
+#
+add_subdirectory(include)
 add_subdirectory(src)
-add_subdirectory(tools)
-add_subdirectory(tests)
-add_subdirectory(benchmark)
-
-if (SIMDJSON_GOOGLE_BENCHMARKS)
-  if(NOT EXISTS dependencies/benchmark/CMakeLists.txt)
-    # message(STATUS "Unable to find dependencies/benchmark/CMakeLists.txt")
-    execute_process(COMMAND git submodule update --init -- dependencies/benchmark
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-  endif()
-  option(BENCHMARK_ENABLE_TESTING OFF)
-  set(BENCHMARK_ENABLE_TESTING OFF)
-  option(BENCHMARK_ENABLE_INSTALL OFF)
-  set(BENCHMARK_ENABLE_INSTALL OFF)
-  add_subdirectory(dependencies/benchmark)
+add_subdirectory(windows)
+if(NOT(SIMDJSON_JUST_LIBRARY))
+  add_subdirectory(dependencies) ## This needs to be before tools because of cxxopts
+  add_subdirectory(tools)  ## This needs to be before tests because of cxxopts
+  add_subdirectory(singleheader)
 endif()
+install(FILES singleheader/simdjson.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

-# for fuzzing, read the comments in the fuzz/CMakeLists.txt file
-option(ENABLE_FUZZING "enable building the fuzzers" ON)
-if(ENABLE_FUZZING)
+#
+# Compile tools / tests / benchmarks
+#
+if(NOT(SIMDJSON_JUST_LIBRARY))
+  add_subdirectory(tests)
+  add_subdirectory(examples)
+  add_subdirectory(benchmark)
  add_subdirectory(fuzz)
 endif()

+#
+# Source files should be just ASCII
+#
+find_program(FIND find)
+find_program(FILE file)
+find_program(GREP grep)
+if((FIND) AND (FILE) AND (GREP))
+    add_test(
+      NAME "just_ascii"
+      COMMAND sh -c "${FIND}  include src windows tools singleheader tests examples benchmark -path benchmark/checkperf-reference -prune -name '*.h'  -o -name '*.cpp' -type f  -exec ${FILE} '{}' \; |${GREP} -v ASCII || exit 0  && exit 1"
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+endif()
+
+
+#
+# CPack
+#
 set(CPACK_PACKAGE_VENDOR "Daniel Lemire")
 set(CPACK_PACKAGE_CONTACT "lemire@gmail.com")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Parsing gigabytes of JSON per second")
@@ -99,5 +85,3 @@ set(CPACK_RPM_PACKAGE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
 set(CPACK_SOURCE_GENERATOR "TGZ;ZIP")

 include(CPack)
-
-
@@ -5,7 +5,7 @@ The simdjson library is an open project written in C++. Contributions are invite
 agree to the project's license.

 We have an extensive list of issues, and contributions toward any of these issues is invited.
-Contributions can take the form of code samples, better documentation or design ideas. 
+Contributions can take the form of code samples, better documentation or design ideas.

 In particular, the following contributions are invited:

@@ -32,7 +32,20 @@ We discourage the following types of contributions:

 In short, most code changes should either bring new features or better performance. We want to avoid unmotivated code changes.

-Guidelines
+
+Specific rules
+----------
+
+We have few hard rules, but we have some:
+
+- Printing to standard output or standard error (`stderr`, `stdout`, `std::cerr`, `std::cout`) in the core library is forbidden. This follows from the [Writing R Extensions](https://cran.r-project.org/doc/manuals/R-exts.html) manual which states that "Compiled code should not write to stdout or stderr".
+- 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_`.
+
+Tools, tests and benchmarks are not held to these same strict rules.
+
+General Guidelines
 ----------

 Contributors are encouraged to :
@@ -43,11 +56,41 @@ Contributors are encouraged to :
 - Tools may report "problems" with the code, but we never delegate programming to tools: if there is a problem with the code, we need to understand it. Thus we will not "fix" code merely to please a static analyzer if we do not understand.
 - Provide tests for any new feature. We will not merge a new feature without tests.

+Pull Requests
+--------------
+
+Pull requests are always invited. However, we ask that you follow these guidelines:
+
+- It is wiser to discuss your ideas first as part of an issue before you start coding. If you omit this step and code first, be prepare to have your code receive scrutiny and be dropped.
+- Users should provide a rationale for their changes. Does it improve performance? Does it add a feature? Does it improve maintainability? Does fix a bug? This must be explicitly stated as part of the pull request. Do not propose changes based on taste or intuition. We do not delegate programming to tools: that some tool suggested a code change is not reason enough to change the code.
+   1. When your code improves performance, please document the gains with a benchmark using hard numbers.
+   2. If your code fixes a bug, please be either fix a failing test, or propose a new test.
+   3. Other types of changes must be clearly motivated. We openly discourage changes with no identifiable benefits.
+- Changes should be focused and minimal. You should change as few lines of code as possible. Please do not reformat or touch files needlessly.
+- New features must be accompanied of new tests, in general.
+- Your code should pass our continuous-integration tests. It is your responsability to ensure that your proposal pass the tests. We do not merge pull requests that would break our build.
+
+If the benefits of your proposed code remain unclear, we may choose to discard your code: that is not an insult, we frequently discard our own code. We may also consider various alternatives and choose another path. Again, that is not an insult or a sign that you have wasted your time.
+
+Style
+-----
+
+Our formatting style is inspired by the LLVM style.
+The simdjson library is written using the snake case: when a variable or a function is a phrase,  each space is replaced by an underscore character, and the first letter of each word written in lowercase.  Compile-time constants are written entirely in uppercase with the same underscore convention.
+
 Code of Conduct
 ---------------

 Though we do not have a formal code of conduct, we will not tolerate bullying, bigotry or
-intimidation. Everyone is welcome to contribute.
+intimidation. Everyone is welcome to contribute. If you have concerns, you can raise them privately with the core team members (e.g., D. Lemire, J. Keiser).
+
+We welcome contributions from women and less represented groups. If you need help, please reach out.
+
+Consider the following points when engaging with the project:
+
+- We discourage arguments from authority: ideas are discusssed on their own merits and not based on who stated it.
+- Be mindful that what you may view as an aggression is maybe merely a difference of opinion or a misunderstanding.
+- Be mindful that a collection of small aggressions, even if mild in isolation, can become harmful.

 Getting Started Hacking
 -----------------------
@@ -31,5 +31,9 @@ Paul Dreik
 Jeremie Piotte
 Matthew Wilson
 Dušan Jovanović
+Matjaž Ostroveršnik
+Nong Li
+Furkan Taşkale
+Brendan Knapp
 # if you have contributed to the project and your name does not 
 # appear in this list, please let us know!
@@ -1,10 +1,88 @@
-# docker build -t simdjson . && docker run --privileged -t simdjson
-FROM gcc:8.3
-COPY . /usr/src/
-WORKDIR /usr/src/
-RUN make clean
-RUN make amalgamate
-RUN make
-RUN make test
-RUN make parsingcompetition
-CMD ["bash", "scripts/selectparser.sh"]
+###
+#
+# Though simdjson requires only commonly available compilers and tools, it can
+# be convenient to build it and test it inside a docker container: it makes it
+# possible to test and benchmark simdjson under even relatively out-of-date
+# Linux servers. It should also work under macOS and Windows, though not
+# at native speeds, maybe.
+#
+# Assuming that you have a working docker server, this file
+# allows you to build, test and benchmark simdjson.
+#
+#  We build the library and associated files in the dockerbuild subdirectory.
+# It may be necessary to delete it before creating the image:
+#
+# rm -r -f dockerbuild
+#
+# The need to delete the directory has nothing to do with docker per se: it is
+# simply cleaner in CMake to start from a fresh directory. This is important: if you
+# reuse the same directory with different configurations, you may get broken builds.
+#
+#
+# Then you can build the image as follows:
+#
+# docker build -t simdjson --build-arg USER_ID=$(id -u)  --build-arg GROUP_ID=$(id -g) .
+#
+# Please note that the image does not contain a copy of the code. However, the image will contain the
+# the compiler and the build system. This means that if you change the source code, after you have built
+# the image, you won't need to rebuild the image. In fact, unless you want to try a different compiler, you
+# do not need to ever rebuild the image, even if you do a lot of work on the source code.
+#
+# We specify the users to avoid having files owned by a privileged user (root) in our directory. Some
+# people like to run their machine as the "root" user. We do not think it is cool.
+#
+# Then you need to build the project:
+#
+# docker run  -v $(pwd):/project:Z  simdjson
+#
+# Should you change a source file, you may need to call this command again. Because the output
+# files are persistent between calls to this command (they reside in the dockerbuild directory),
+# this command can be fast.
+#
+# Next you can test it as follows:
+#
+# docker run -it -v $(pwd):/project:Z   simdjson sh -c "cd dockerbuild && ctest . --output-on-failure -E checkperf"
+#
+# The run the complete tests requires you to have built all of simdjson.
+#
+# Building all of simdjson takes a long time. Instead, you can build just one target:
+#
+# docker run -it -v $(pwd):/project:Z  simdjson sh -c "[ -d dockerbuild ] || mkdir dockerbuild && cd dockerbuild && cmake ..  && cmake --build . --target parse"
+#
+# Note that it is safe to remove dockerbuild before call the previous command, as the repository gets rebuild. It is also possible, by changing the command, to use a different directory name.
+#
+# You can run performance tests:
+#
+# docker run -it --privileged -v $(pwd):/project:Z  simdjson sh -c "cd dockerbuild && for i in ../jsonexamples/*.json; do echo \$i; ./benchmark/parse \$i;  done"
+#
+# The "--privileged" is recommended so you can get performance counters under Linux.
+#
+# You can also grab a fresh copy of simdjson and rebuild it, to make comparisons:
+#
+# docker run -it -v $(pwd):/project:Z  simdjson sh -c "git clone https://github.com/simdjson/simdjson.git && cd simdjson && mkdir build && cd build && cmake .. && cmake --build . --target parse "
+#
+# Then you can run comparisons:
+#
+# docker run -it --privileged -v $(pwd):/project:Z  simdjson sh -c "for i in jsonexamples/*.json; do echo \$i; dockerbuild/benchmark/parse \$i| grep GB| head -n 1; simdjson/build/benchmark/parse \$i | grep GB |head -n 1;  done"
+#
+####
+FROM ubuntu:20.10
+################
+# We would prefer to use the conan io images but they do not support 64-bit ARM? The small gcc images appear to
+# be broken on ARM.
+# Furthermore, we would not expect users to frequently rebuild the container, so using ubuntu is probably fine.
+###############
+ARG USER_ID
+ARG GROUP_ID
+RUN apt-get update -qq
+RUN DEBIAN_FRONTEND="noninteractive" apt-get -y install tzdata
+RUN apt-get install -y cmake g++ git
+RUN mkdir project
+
+RUN addgroup --gid $GROUP_ID user; exit 0
+RUN adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID user; exit 0
+USER user
+RUN gcc --version
+WORKDIR /project
+
+CMD ["sh","-c","[ -d dockerbuild ] || mkdir dockerbuild && cd dockerbuild && cmake .. && cmake --build . "]
@@ -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         =
+PROJECT_NUMBER         = "0.6.0"

 # 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
@@ -51,7 +51,7 @@ PROJECT_BRIEF          = "Ridiculously Fast JSON"
 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
 # the logo to the output directory.

-PROJECT_LOGO           =
+PROJECT_LOGO           = images/logotiny.png

 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
 # into which the generated documentation will be written. If a relative path is
@@ -829,7 +829,7 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.

-INPUT                  = include
+INPUT                  = doc include

 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -1026,7 +1026,7 @@ FILTER_SOURCE_PATTERNS =
 # (index.html). This can be useful if you have a project on for instance GitHub
 # and want to reuse the introduction page also for the doxygen output.

-USE_MDFILE_AS_MAINPAGE =
+USE_MDFILE_AS_MAINPAGE = doc/basics_doxygen.md

 #---------------------------------------------------------------------------
 # Configuration options related to source browsing
@@ -1,33 +1,63 @@
 Hacking simdjson
 ================

-Here is wisdom about how to build, test and run simdjson from within the repository. *Users* of
-simdjson should use the released simdjson.h and simdjson.cpp files.
+Here is wisdom about how to build, test and run simdjson from within the repository. This is mostly useful for people who plan to contribute simdjson, or maybe study the design.
+
+If you plan to contribute to simdjson, please read our [CONTRIBUTING](https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md) guide.
+
+
+Design notes
+------------------------------
+
+The parser works in two stages:
+
+- Stage 1. (Find marks) Identifies quickly structure elements, strings, and so forth. We validate UTF-8 encoding at that stage.
+- Stage 2. (Structure building) Involves constructing a "tree" of sort (materialized as a tape) to navigate through the data. Strings and numbers are parsed at this stage.
+
+
+The role of stage 1 is to identify pseudo-structural characters as quickly as possible. A character is pseudo-structural if and only if:
+
+1. Not enclosed in quotes, AND
+2. Is a non-whitespace character, AND
+3. Its preceding character is either:
+   (a) a structural character, OR
+   (b) whitespace OR
+   (c) the final quote in a string.
+
+This helps as we redefine some new characters as pseudo-structural such as the characters 1, G, n in the following:
+
+> { "foo" : 1.5, "bar" : 1.5 GEOFF_IS_A_DUMMY bla bla , "baz", null }
+
+Stage 1 also does unicode validation.
+
+Stage 2 handles all of the rest: number parsings, recognizing atoms like true, false, null, and so forth.
+

 Directory Structure and Source
 ------------------------------

 simdjson's source structure, from the top level, looks like this:

-* **Makefile:** The main Makefile for Linux. This is not the same as CMakeLists.txt.
-* **CMakeLists.txt:** A Makefile generator for non-default cases and options.
+* **CMakeLists.txt:** The main build system.
 * **include:** User-facing declarations and inline definitions (most user-facing functions are inlined).
-  * simdjson.h: A "master include" that includes files from include/simdjson/. This is equivalent to
+  * simdjson.h: A "main include" that includes files from include/simdjson/. This is equivalent to
    the distributed simdjson.h.
  * simdjson/*.h: Declarations for public simdjson classes and functions.
-  * simdjson/inline/*.h: Definitions for public simdjson classes and functions.
+  * simdjson/*-inl.h: Definitions for public simdjson classes and functions.
 * **src:** The source files for non-inlined functionality (e.g. the architecture-specific parser
  implementations).
-  * simdjson.cpp: A "master source" that includes all implementation files from src/. This is
+  * 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/|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
    enclosed in a namespace, e.g.:
    ```c++
-    namespace simdjson::haswell {
-      #include "generic/stage1_find_marks.h"
+    namespace simdjson {
+      namespace haswell {
+        #include "generic/stage1/json_structural_indexer.h"
+      }
    }
    ```

@@ -35,91 +65,143 @@ Other important files and directories:
 * **.drone.yml:** Definitions for Drone CI.
 * **.appveyor.yml:** Definitions for Appveyor CI (Windows).
 * **.circleci:** Definitions for Circle CI.
-* **amalgamation.sh:** Generates singleheader/simdjson.h and singleheader/simdjson.cpp for release.
+* **.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). 
 * **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. If you're not sure what else to do to check your performance, this is always a good start:
+  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:
  ```bash
-  make parse && ./parse jsonexamples/twitter.json
+  mkdir build
+  cd build
+  cmake ..
+  cmake --build . --config Release
+  benchmark/parse ../jsonexamples/twitter.json
  ```
+  The last line becomes `./benchmark/Release/parse.exe ../jsonexample/twitter.json` under Windows. You may also use Google Benchmark:
+  ```bash
+  mkdir build
+  cd build
+  cmake ..
+  cmake --build . --target bench_parse_call --config Release
+  ./benchmark/bench_parse_call
+  ```
+  The last line becomes `./benchmark/Release/bench_parse_call.exe` under Windows. Under Windows, you can also build with the clang compiler by adding `-T ClangCL` to the call to `cmake ..`: `cmake .. - TClangCL`.
+* **fuzz:** The source for fuzz testing. This lets us explore important edge and middle cases
 * **fuzz:** The source for fuzz testing. This lets us explore important edge and middle cases
  automatically, and is run in CI.
 * **jsonchecker:** A set of JSON files used to check different functionality of the parser.
  * **pass*.json:** Files that should pass validation.
  * **fail*.json:** Files that should fail validation.
+  * **jsonchecker/minefield/y_*.json:** Files that should pass validation.
+  * **jsonchecker/minefield/n_*.json:** Files that should fail validation.
 * **jsonexamples:** A wide spread of useful, real-world JSON files with different characteristics
  and sizes.
-* **singleheader:** Contains generated simdjson.h and simdjson.cpp that we release.
 * **test:** The tests are here. basictests.cpp and errortests.cpp are the primary ones.
-* **tools:** Source for executables that can be distributed with simdjson
+* **tools:** Source for executables that can be distributed with simdjson. Some examples:
+  * `json2json mydoc.json` parses the document, constructs a model and then dumps back the result to standard output.
+  * `json2json -d mydoc.json` parses the document, constructs a model and then dumps model (as a tape) to standard output. The tape format is described in the accompanying file `tape.md`.
+  * `minify mydoc.json` minifies the JSON document, outputting the result to standard output. Minifying means to remove the unneeded white space characters.
+  *`jsonpointer mydoc.json <jsonpath> <jsonpath> ... <jsonpath>` parses the document, constructs a model and then processes a series of [JSON Pointer paths](https://tools.ietf.org/html/rfc6901). The result is itself a JSON document.
+

 > **Don't modify the files in singleheader/ directly; these are automatically generated.**
-> 
-> While we distribute those files on release, we *maintain* the files under include/ and src/.
+

 While simdjson distributes just two files from the singleheader/ directory, we *maintain* the code in
-multiple files under include/ and src/. include/simdjson.h and src/simdjson.cpp are the "spine" for
-these, and you can include
+multiple files under include/ and src/. The files include/simdjson.h and src/simdjson.cpp are the "spine" for
+these, and you can include them as if they were the corresponding singleheader/ files.

-Regenerating Single Headers From Master
+
+
+Runtime Dispatching
+--------------------
+
+A key feature of simdjson is the ability to compile different processing kernels, optimized for specific instruction sets, and to select
+the most appropriate kernel at runtime. This ensures that users get the very best performance while still enabling simdjson to run everywhere.
+This technique is frequently called runtime dispatching. The simdjson achieves runtime dispatching entirely in C++: we do not assume
+that the user is building the code using CMake, for example.
+
+To make runtime dispatching work, it is critical that the code be compiled for the lowest supported processor. In particular, you should
+not use flags such as -mavx2, /arch:AVX2 and so forth while compiling simdjson. When you do so, you allow the compiler to use advanced
+instructions. In turn, these advanced instructions present in the code may cause a runtime failure if the runtime processor does not
+support them. Even a simple loop, compiled with these flags, might generate binary code that only run on advanced processors.
+
+So we compile simdjson for a generic processor. Our users should do the same if they want simdjson's runtime dispatch to work. It is important
+to understand that if runtime dispatching does not work, then simdjson will cause crashes on older processors. Of course, if a user chooses
+to compile their code for a specific instruction set (e.g., AVX2), they are responsible for the failures if they later run their code
+on a processor that does not support AVX2. Yet, if we were to entice these users to do so, we would share the blame: thus we carefully instruct
+users to compile their code in a generic way without doing anything to enable advanced instructions.
+
+
+We only use runtime dispatching on x64 (AMD/Intel) platforms, at the moment. On ARM processors, we would need a standard way to query, at runtime,
+the processor for its supported features. We do not know how to do so on ARM systems in general. Thankfully it is not yet a concern: 64-bit ARM
+processors are fairly uniform as far as the instruction sets they support.
+
+
+In all cases, simdjson uses advanced instructions by relying on  "intrinsic functions": we do not write assembly code. The intrinsic functions
+are special functions that the compiler might recognize and translate into fast code. To make runtime dispatching work, we rely on the fact that
+the header providing these instructions
+(intrin.h under Visual Studio, x86intrin.h elsewhere) defines all of the intrinsic functions, including those that are not supported
+processor.
+
+At this point, we are require to use one of two main strategies.
+
+1. On POSIX systems, the main compilers (LLVM clang, GNU gcc) allow us to use any intrinsic function after including the header, but they fail to inline the resulting instruction if the target processor does not support them. Because we compile for a generic processor, we would not be able to use most intrinsic functions. Thankfully, more recent versions of these compilers allow us to flag a region of code with a specific target, so that we can compile only some of the code with support for advanced instructions. Thus in our C++, one might notice macros like `TARGET_HASWELL`. It is then our responsability, at runtime, to only run the regions of code (that we call kernels) matching the properties of the runtime processor. The benefit of this approach is that the compiler not only let us use intrinsic functions, but it can also optimize the rest of the code in the kernel with advanced instructions we enabled.
+
+2. Under Visual Studio, the problem is somewhat simpler. Visual Studio will not only provide the intrinsic functions, but it will also allow us to use them. They will compile just fine. It is at runtime that they may cause a crash. So we do not need to mark regions of code for compilation toward advanced processors (e.g., with  `TARGET_HASWELL` macros). The downside of the Visual Studio approach is that the compiler is not allowed to use advanced instructions others than those we specify. In principle, this means that Visual Studio has weaker optimization opportunities.
+
+
+
+We also handle the special case where a user is compiling using LLVM clang under Windows, [using the Visual Studio toolchain](https://devblogs.microsoft.com/cppblog/clang-llvm-support-in-visual-studio/). If you compile with LLVM clang under Visual Studio, then the header files (intrin.h or x86intrin.h) no longer provides the intrinsic functions that are unsupported by the processor. This appears to be deliberate on the part of the LLVM engineers. With a few lines of code, we handle this scenario just like LLVM clang under a POSIX system, but forcing the inclusion of the specific headers, and rolling our own intrinsic function as needed.
+
+
+
+
+
+Regenerating Single-Header Files
 ---------------------------------------

-simdjson.h and simdjson.cpp are not always up to date in master. To ensure you have the latest copy,
-you can regenerate them by running this at the top level:
+The simdjson.h and simdjson.cpp files in the singleheader directory are not always up-to-date with the rest of the code; they are only ever
+systematically regenerated on releases. To ensure you have the latest code, you can regenerate them by running this at the top level:

 ```bash
-make amalgamate
+mkdir build
+cd build
+cmake ..
+cmake --build . --target amalgamate
 ```

-The amalgamator is at `amalgamation.sh` at the top level. It generates singleheader/simdjson.h by
+You need to have a working bash on your system.
+
+The amalgamator script is `amalgamate.sh` 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
 times.

-### Usage (old-school Makefile on platforms like Linux or macOS)
+### Usage (CMake on 64-bit platforms like Linux, FreeBSD or macOS)

-Requirements: recent clang or gcc, and make. We recommend at least GNU GCC/G++ 7 or LLVM clang 6. A 64-bit system like Linux or macOS is expected.
-
-To test:
-
-```
-make
-make test
-```
-
-To run benchmarks:
-
-```
-make parse
-./parse jsonexamples/twitter.json
-```
-
-Under Linux, the `parse` command gives a detailed analysis of the performance counters.
-
-To run comparative benchmarks (with other parsers):
-
-```
-make benchmark
-```
-
-### Usage (CMake on 64-bit platforms like Linux or macOS)
-
-Requirements: We require a recent version of cmake. On macOS, the easiest way to install cmake might be to use [brew](https://brew.sh) and then type
+Requirements: In addition to git, we require a recent version of CMake as well as bash.

+1. On macOS, the easiest way to install cmake might be to use [brew](https://brew.sh) and then type
 ```
 brew install cmake
 ```
-
-There is an [equivalent brew on Linux which works the same way as well](https://linuxbrew.sh).
-
-You need a recent compiler like clang or gcc. We recommend at least GNU GCC/G++ 7 or LLVM clang 6. For example, you can install a recent compiler with brew:
-
+2. Under Linux, you might be able to install CMake as follows:
 ```
-brew install gcc@8
+apt-get update -qq
+apt-get install -y cmake
+```
+3. On FreeBSD, you might be able to install bash and CMake as follows:
+```
+pkg update -f
+pkg install bash
+pkg install cmake
 ```

-Optional: You need to tell cmake which compiler you wish to use by setting the CC and CXX variables. Under bash, you can do so with commands such as `export CC=gcc-7` and `export CXX=g++-7`.
+You need a recent compiler like clang or gcc. We recommend at least GNU GCC/G++ 7 or LLVM clang 6.
+

 Building: While in the project repository, do the following:

@@ -127,8 +209,8 @@ Building: While in the project repository, do the following:
 mkdir build
 cd build
 cmake ..
-make
-make test
+cmake --build .
+ctest
 ```

 CMake will build a library. By default, it builds a shared library (e.g., libsimdjson.so on Linux).
@@ -139,11 +221,11 @@ You can build a static library:
 mkdir buildstatic
 cd buildstatic
 cmake -DSIMDJSON_BUILD_STATIC=ON ..
-make
-make test
+cmake --build .
+ctest
 ```

-In some cases, you may want to specify your compiler, especially if the default compiler on your system is too old. You may proceed as follows:
+In some cases, you may want to specify your compiler, especially if the default compiler on your system is too old.  You need to tell cmake which compiler you wish to use by setting the CC and CXX variables. Under bash, you can do so with commands such as `export CC=gcc-7` and `export CXX=g++-7`. You can also do it as part of the `cmake` command: `cmake .. -DCMAKE_CXX_COMPILER=g++`.  You may proceed as follows:

 ```
 brew install gcc@8
@@ -151,213 +233,50 @@ mkdir build
 cd build
 export CXX=g++-8 CC=gcc-8
 cmake ..
-make
-make test
+cmake --build .
+ctest
 ```

-### Usage (CMake on 64-bit Windows using Visual Studio)
+If your compiler does not default on C++11 support or better you may get failing tests. If so, you may be able to exclude the failing  tests by replacing `ctest` with `ctest  -E "^quickstart$"`.

-We assume you have a common 64-bit Windows PC with at least Visual Studio 2017 and an x64 processor with AVX2 support (2013 Intel Haswell or later) or SSE 4.2 + CLMUL (2010 Westmere or later).
+Note that the name of directory (`build`) is arbitrary, you can name it as you want (e.g., `buildgcc`) and you can have as many different such directories as you would like (one per configuration).
+
+
+
+### Usage (CMake on 64-bit Windows using Visual Studio 2019)
+
+We assume you have a common 64-bit Windows PC with at least Visual Studio 2019.

 - Grab the simdjson code from GitHub, e.g., by cloning it using [GitHub Desktop](https://desktop.github.com/).
 - 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 `VisualStudio`.
- Using a shell, go to this newly created directory.
- Type `cmake -DCMAKE_GENERATOR_PLATFORM=x64 ..` in the shell while in the `VisualStudio` repository. (Alternatively, if you want to build a DLL, you may use the command line `cmake -DCMAKE_GENERATOR_PLATFORM=x64 -DSIMDJSON_BUILD_STATIC=OFF ..`.)
+- 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. 
 - 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`.

-### Usage (Using `vcpkg` on 64-bit Windows, Linux and macOS)

-[vcpkg](https://github.com/Microsoft/vcpkg) users on Windows, Linux and macOS can download and install `simdjson` with one single command from their favorite shell.
+Though having Visual Studio installed is necessary, one can build simdjson using only cmake commands:

-On 64-bit Linux and macOS:
-
-```
-$ ./vcpkg install simdjson
-```
-
-will build and install `simdjson` as a static library.
-
-On Windows (64-bit):
-
-```
-.\vcpkg.exe install simdjson:x64-windows
-```
-
-will build and install `simdjson` as a shared library.
-
-```
-.\vcpkg.exe install simdjson:x64-windows-static  
-```
-
-will build and install `simdjson` as a static library.
-
-These commands will also print out instructions on how to use the library from MSBuild or CMake-based projects.
-
-If you find the version of `simdjson` shipped with `vcpkg` is out-of-date, feel free to report it to
-`vcpkg` community either by submitting an issue or by creating a PR.
-
-### Usage (Docker)
-
-One can run tests and benchmarks using docker. It especially makes sense under Linux. Privileged
-access may be needed to get performance counters.
-
-```
-git clone https://github.com/simdjson/simdjson.git
-cd simdjson
-docker build -t simdjson .
-docker run --privileged -t simdjson
-```
-
-## Architecture and Design Notes
-
-### Requirements
-
- 64-bit platforms like Linux or macOS, as well as Windows through Visual Studio 2017 or later.
- Any 64-bit processor:
-  - AVX2 (i.e., Intel processors starting with the Haswell microarchitecture released 2013 and AMD
-    processors starting with the Zen microarchitecture released 2017),
-  - SSE 4.2 and CLMUL (i.e., Intel processors going back to Westmere released in 2010 or AMD
-    processors starting with the Jaguar used in the PS4 and XBox One),
-  - 64-bit ARM processor (ARMv8-A NEON): this covers a wide range of mobile processors, including
-    all Apple processors currently available for sale, going as far back as the iPhone 5s (2013).
-  - Any 64-bit processor (simdjson has a fallback generic 64-bit implementation that is still super
-    fast).
- A recent C++ compiler (e.g., GNU GCC or LLVM CLANG or Visual Studio 2017), we assume C++17. GNU
-  GCC 7 or better or LLVM's clang 6 or better.
- Some benchmark scripts assume bash and other common utilities, but they are optional.
-
-### Scope
-
-We provide a fast parser, that fully validates an input according to various specifications.
-The parser builds a useful immutable (read-only) DOM (document-object model) which can be later accessed.
-
-To simplify the engineering, we make some assumptions.
-
- We support UTF-8 (and thus ASCII), nothing else (no Latin, no UTF-16). We do not believe this is a
-  genuine limitation, because we do not think there is any serious application that needs to process
-  JSON data without an ASCII or UTF-8 encoding. If the UTF-8 contains a leading BOM, it should be
-  omitted: the user is responsible for detecting and skipping the BOM; UTF-8 BOMs are discouraged.
- All strings in the JSON document may have up to 4294967295 bytes in UTF-8 (4GB). To enforce this
-  constraint, we refuse to parse a document that contains more than 4294967295 bytes (4GB). This
-  should accommodate most JSON documents.
- As allowed by the specification, we allow repeated keys within an object (other parsers like
-  sajson do the same).
- [The simdjson library is fast for JSON documents spanning a few bytes up to many megabytes](https://github.com/lemire/simdjson/issues/312).
-
-_We do not aim to provide a general-purpose JSON library._ A library like RapidJSON offers much more
-than just parsing, it helps you generate JSON and offers various other convenient functions. We
-merely parse the document. This may change in the future.
-
-### Features
-
- The input string is unmodified. (Parsers like sajson and RapidJSON use the input string as a buffer.)
- We parse integers and floating-point numbers as separate types which allows us to support large signed 64-bit integers in [-9223372036854775808,9223372036854775808), like a Java `long` or a C/C++ `long long` and large unsigned integers up to the value 18446744073709551615. Among the parsers that differentiate between integers and floating-point numbers, not all support 64-bit integers. (For example, sajson rejects JSON files with integers larger than or equal to 2147483648. RapidJSON will parse a file containing an overly long integer like 18446744073709551616 as a floating-point number.) 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.
- We test for accurate float parsing with a perfect accuracy (ULP 0). Many parsers offer only approximate floating parsing. For example, RapidJSON also offers the option of accurate float parsing (`kParseFullPrecisionFlag`) but it comes at a significant performance penalty compared to the default settings. By default, RapidJSON tolerates an error of 3 ULP.
- We do full UTF-8 validation as part of the parsing. (Parsers like fastjson, gason and dropbox json11 do not do UTF-8 validation. The sajson parser does incomplete UTF-8 validation, accepting code point
-sequences like 0xb1 0x87.)
- We fully validate the numbers. (Parsers like gason and ultranjson will accept `[0e+]` as valid JSON.)
- We validate string content for unescaped characters. (Parsers like fastjson and ultrajson accept unescaped line breaks and tabs in strings.)
- We fully validate the white-space characters outside of the strings. Parsers like RapidJSON will accept JSON documents with null characters outside of strings.
-
-### Architecture
-
-The parser works in two stages:
-
- Stage 1. (Find marks) Identifies quickly structure elements, strings, and so forth. We validate UTF-8 encoding at that stage.
- Stage 2. (Structure building) Involves constructing a "tree" of sort (materialized as a tape) to navigate through the data. Strings and numbers are parsed at this stage.
-
-### Remarks on JSON parsing
-
- The JSON spec defines what a JSON parser is:
-  > A JSON parser transforms a JSON text into another representation. A JSON parser MUST accept all texts that conform to the JSON grammar. A JSON parser MAY accept non-JSON forms or extensions. An implementation may set limits on the size of texts that it accepts. An implementation may set limits on the maximum depth of nesting. An implementation may set limits on the range and precision of numbers. An implementation may set limits on the length and character contents of strings.
-
-* JSON is not JavaScript:
-
-  > All JSON is Javascript but NOT all Javascript is JSON. So {property:1} is invalid because property does not have double quotes around it. {'property':1} is also invalid, because it's single quoted while the only thing that can placate the JSON specification is double quoting. JSON is even fussy enough that {"property":.1} is invalid too, because you should have of course written {"property":0.1}. Also, don't even think about having comments or semicolons, you guessed it: they're invalid. (credit:https://github.com/elzr/vim-json)
-
-* The structural characters are:
-
-      begin-array     =  [ left square bracket
-      begin-object    =  { left curly bracket
-      end-array       =  ] right square bracket
-      end-object      =  } right curly bracket
-      name-separator  = : colon
-      value-separator = , comma
-
-### Pseudo-structural elements
-
-A character is pseudo-structural if and only if:
-
-1. Not enclosed in quotes, AND
-2. Is a non-whitespace character, AND
-3. Its preceding character is either:
-   (a) a structural character, OR
-   (b) whitespace.
-
-This helps as we redefine some new characters as pseudo-structural such as the characters 1, G, n in the following:
-
-> { "foo" : 1.5, "bar" : 1.5 GEOFF_IS_A_DUMMY bla bla , "baz", null }
-
-## About the Project
-
-### Bindings and Ports of simdjson
-
-We distinguish between "bindings" (which just wrap the C++ code) and a port to another programming language (which reimplements everything).
+- `mkdir build`
+- `cd build`
+- `cmake ..`
+- `cmake --build . -config Release`


- [ZippyJSON](https://github.com/michaeleisel/zippyjson): Swift bindings for the simdjson project.
- [pysimdjson](https://github.com/TkTech/pysimdjson): Python bindings for the simdjson project.
- [simdjson-rs](https://github.com/Licenser/simdjson-rs): Rust port.
- [simdjson-rust](https://github.com/SunDoge/simdjson-rust): Rust wrapper (bindings).
- [SimdJsonSharp](https://github.com/EgorBo/SimdJsonSharp): C# version for .NET Core (bindings and full port).
- [simdjson_nodejs](https://github.com/luizperes/simdjson_nodejs): Node.js bindings for the simdjson project.
- [simdjson_php](https://github.com/crazyxman/simdjson_php): PHP bindings for the simdjson project.
- [simdjson_ruby](https://github.com/saka1/simdjson_ruby): 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.
+Furthermore, if you have installed LLVM clang on Windows, for example as a component of Visual Studio 2019, you can configure and build simdjson using LLVM clang on Windows using cmake:

-### Tools

- `json2json mydoc.json` parses the document, constructs a model and then dumps back the result to standard output.
- `json2json -d mydoc.json` parses the document, constructs a model and then dumps model (as a tape) to standard output. The tape format is described in the accompanying file `tape.md`.
- `minify mydoc.json` minifies the JSON document, outputting the result to standard output. Minifying means to remove the unneeded white space characters.
- `jsonpointer mydoc.json <jsonpath> <jsonpath> ... <jsonpath>` parses the document, constructs a model and then processes a series of [JSON Pointer paths](https://tools.ietf.org/html/rfc6901). The result is itself a JSON document.
+- `mkdir build`
+- `cd build`
+- `cmake ..  -T ClangCL`
+- `cmake --build . -config Release`

-### In-depth comparisons
-
-If you want to see how a wide range of parsers validate a given JSON file:
-
-```
-make allparserscheckfile
-./allparserscheckfile myfile.json
-```
-
-For performance comparisons:
-
-```
-make parsingcompetition
-./parsingcompetition myfile.json
-```
-
-For broader comparisons:
-
-```
-make allparsingcompetition
-./allparsingcompetition myfile.json
-```
-
-Both the `parsingcompetition` and `allparsingcompetition` tools take a `-t` flag which produces
-a table-oriented output that can be conveniently parsed by other tools.

 ### Various References

- [Google double-conv](https://github.com/google/double-conversion/)
 - [How to implement atoi using SIMD?](https://stackoverflow.com/questions/35127060/how-to-implement-atoi-using-simd)
 - [Parsing JSON is a Minefield 💣](http://seriot.ch/parsing_json.php)
 - https://tools.ietf.org/html/rfc7159
- The Mison implementation in rust https://github.com/pikkr/pikkr
 - http://rapidjson.org/md_doc_sax.html
 - https://github.com/Geal/parser_benchmarks/tree/master/json
 - Gron: A command line tool that makes JSON greppable https://news.ycombinator.com/item?id=16727665
@@ -371,31 +290,3 @@ Inspiring links:
 - https://auth0.com/blog/beating-json-performance-with-protobuf/
 - https://gist.github.com/shijuvar/25ad7de9505232c87034b8359543404a
 - https://github.com/frankmcsherry/blog/blob/master/posts/2018-02-11.md
-
-Validating UTF-8 takes no more than 0.7 cycles per byte:
-
- https://github.com/lemire/fastvalidate-utf-8 https://lemire.me/blog/2018/05/16/validating-utf-8-strings-using-as-little-as-0-7-cycles-per-byte/
-
-### Academic References
-
- T.Mühlbauer, W.Rödiger, R.Seilbeck, A.Reiser, A.Kemper, and T.Neumann. Instant loading for main memory databases. PVLDB, 6(14):1702–1713, 2013. (SIMD-based CSV parsing)
- Mytkowicz, Todd, Madanlal Musuvathi, and Wolfram Schulte. "Data-parallel finite-state machines." ACM SIGARCH Computer Architecture News. Vol. 42. No. 1. ACM, 2014.
- Lu, Yifan, et al. "Tree structured data processing on GPUs." Cloud Computing, Data Science & Engineering-Confluence, 2017 7th International Conference on. IEEE, 2017.
- Sidhu, Reetinder. "High throughput, tree automata based XML processing using FPGAs." Field-Programmable Technology (FPT), 2013 International Conference on. IEEE, 2013.
- Dai, Zefu, Nick Ni, and Jianwen Zhu. "A 1 cycle-per-byte XML parsing accelerator." Proceedings of the 18th annual ACM/SIGDA international symposium on Field programmable gate arrays. ACM, 2010.
- Lin, Dan, et al. "Parabix: Boosting the efficiency of text processing on commodity processors." High Performance Computer Architecture (HPCA), 2012 IEEE 18th International Symposium on. IEEE, 2012. http://parabix.costar.sfu.ca/export/1783/docs/HPCA2012/final_ieee/final.pdf
- Deshmukh, V. M., and G. R. Bamnote. "An empirical evaluation of optimization parameters in XML parsing for performance enhancement." Computer, Communication and Control (IC4), 2015 International Conference on. IEEE, 2015.
- Moussalli, Roger, et al. "Efficient XML Path Filtering Using GPUs." ADMS@ VLDB. 2011.
- Jianliang, Ma, et al. "Parallel speculative dom-based XML parser." High Performance Computing and Communication & 2012 IEEE 9th International Conference on Embedded Software and Systems (HPCC-ICESS), 2012 IEEE 14th International Conference on. IEEE, 2012.
- Li, Y., Katsipoulakis, N.R., Chandramouli, B., Goldstein, J. and Kossmann, D., 2017. Mison: a fast JSON parser for data analytics. Proceedings of the VLDB Endowment, 10(10), pp.1118-1129. http://www.vldb.org/pvldb/vol10/p1118-li.pdf
- Cameron, Robert D., et al. "Parallel scanning with bitstream addition: An xml case study." European Conference on Parallel Processing. Springer, Berlin, Heidelberg, 2011.
- Cameron, Robert D., Kenneth S. Herdy, and Dan Lin. "High performance XML parsing using parallel bit stream technology." Proceedings of the 2008 conference of the center for advanced studies on collaborative research: meeting of minds. ACM, 2008.
- Shah, Bhavik, et al. "A data parallel algorithm for XML DOM parsing." International XML Database Symposium. Springer, Berlin, Heidelberg, 2009.
- Cameron, Robert D., and Dan Lin. "Architectural support for SWAR text processing with parallel bit streams: the inductive doubling principle." ACM Sigplan Notices. Vol. 44. No. 3. ACM, 2009.
- Amagasa, Toshiyuki, Mana Seino, and Hiroyuki Kitagawa. "Energy-Efficient XML Stream Processing through Element-Skipping Parsing." Database and Expert Systems Applications (DEXA), 2013 24th International Workshop on. IEEE, 2013.
- Medforth, Nigel Woodland. "icXML: Accelerating Xerces-C 3.1. 1 using the Parabix Framework." (2013).
- Zhang, Qiang Scott. Embedding Parallel Bit Stream Technology Into Expat. Diss. Simon Fraser University, 2010.
- Cameron, Robert D., et al. "Fast Regular Expression Matching with Bit-parallel Data Streams."
- Lin, Dan. Bits filter: a high-performance multiple string pattern matching algorithm for malware detection. Diss. School of Computing Science-Simon Fraser University, 2010.
- Yang, Shiyang. Validation of XML Document Based on Parallel Bit Stream Technology. Diss. Applied Sciences: School of Computing Science, 2013.
- N. Nakasato, "Implementation of a parallel tree method on a GPU", Journal of Computational Science, vol. 3, no. 3, pp. 132-141, 2012.
@@ -1,301 +0,0 @@
-REFERENCE_VERSION = master
-
-.SUFFIXES:
-#
-.SUFFIXES: .cpp .o .c .h
-
-
-.PHONY: clean cleandist
-COREDEPSINCLUDE = -Idependencies/json/single_include -Idependencies/rapidjson/include -Idependencies/sajson/include -Idependencies/cJSON  -Idependencies/jsmn
-EXTRADEPSINCLUDE =  -Idependencies/jsoncppdist -Idependencies/json11 -Idependencies/fastjson/src -Idependencies/fastjson/include -Idependencies/gason/src -Idependencies/ujson4c/3rdparty -Idependencies/ujson4c/src
-# users can provide their own additional flags with make EXTRAFLAGS=something
-architecture:=$(shell arch)
-
-####
-# If you want to specify your own target architecture,
-# then define ARCHFLAGS. Otherwise, we set good default.
-# E.g., type ' ARCHFLAGS="-march=westmere" make parse '
-###
-
-CXXFLAGS = $(ARCHFLAGS) -std=c++17  -pthread -Wall -Wextra -Wshadow -Ibenchmark/linux
-CFLAGS =  $(ARCHFLAGS) -Idependencies/ujson4c/3rdparty -Idependencies/ujson4c/src $(EXTRAFLAGS)
-
-# This is a convenience flag
-ifdef SANITIZEGOLD
-    SANITIZE = 1
-    LINKER = gold
-endif
-
-ifdef LINKER
-	CXXFLAGS += -fuse-ld=$(LINKER)
-	CFLAGS += -fuse-ld=$(LINKER)
-endif
-
-
-# SANITIZE *implies* DEBUG
-ifeq ($(MEMSANITIZE),1)
-	CXXFLAGS += -g3 -O0  -fsanitize=memory -fno-omit-frame-pointer -fsanitize=undefined
-	CFLAGS += -g3 -O0  -fsanitize=memory -fno-omit-frame-pointer -fsanitize=undefined
-else
-ifeq ($(SANITIZE),1)
-	CXXFLAGS += -g3 -O0  -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined
-	CFLAGS += -g3 -O0  -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined
-else
-ifeq ($(DEBUG),1)
-	CXXFLAGS += -g3 -O0
-	CFLAGS += -g3 -O0
-else
-# we opt for  -O3 for regular builds
-	CXXFLAGS += -O3
-	CFLAGS += -O3
-endif # ifeq ($(DEBUG),1)
-endif # ifeq ($(SANITIZE),1)
-endif # ifeq ($(MEMSANITIZE),1)
-
-# Headers and sources
-SRCHEADERS_GENERIC=src/generic/atomparsing.h src/generic/numberparsing.h src/generic/json_scanner.h src/generic/json_string_scanner.h src/generic/json_structural_indexer.h src/generic/json_minifier.h src/generic/buf_block_reader.h src/generic/stage2_build_tape.h src/generic/stringparsing.h src/generic/stage2_streaming_build_tape.h src/generic/utf8_fastvalidate_algorithm.h src/generic/utf8_lookup_algorithm.h src/generic/utf8_lookup2_algorithm.h src/generic/utf8_range_algorithm.h src/generic/utf8_zwegner_algorithm.h
-SRCHEADERS_ARM64=      src/arm64/bitmanipulation.h    src/arm64/bitmask.h    src/arm64/intrinsics.h    src/arm64/numberparsing.h    src/arm64/simd.h    src/arm64/stage1_find_marks.h    src/arm64/stage2_build_tape.h    src/arm64/stringparsing.h
-SRCHEADERS_HASWELL=  src/haswell/bitmanipulation.h  src/haswell/bitmask.h  src/haswell/intrinsics.h  src/haswell/numberparsing.h  src/haswell/simd.h  src/haswell/stage1_find_marks.h  src/haswell/stage2_build_tape.h  src/haswell/stringparsing.h
-SRCHEADERS_FALLBACK=  src/fallback/bitmanipulation.h src/fallback/implementation.h src/fallback/numberparsing.h src/fallback/stage1_find_marks.h src/fallback/stage2_build_tape.h src/fallback/stringparsing.h
-SRCHEADERS_WESTMERE=src/westmere/bitmanipulation.h src/westmere/bitmask.h src/westmere/intrinsics.h src/westmere/numberparsing.h src/westmere/simd.h src/westmere/stage1_find_marks.h src/westmere/stage2_build_tape.h src/westmere/stringparsing.h
-SRCHEADERS_SRC=src/isadetection.h src/jsoncharutils.h src/simdprune_tables.h src/implementation.cpp src/stage1_find_marks.cpp src/stage2_build_tape.cpp src/document_parser_callbacks.h
-SRCHEADERS=$(SRCHEADERS_SRC) $(SRCHEADERS_GENERIC) $(SRCHEADERS_ARM64) $(SRCHEADERS_HASWELL) $(SRCHEADERS_WESTMERE) $(SRCHEADERS_FALLBACK)
-
-INCLUDEHEADERS=include/simdjson.h include/simdjson/common_defs.h include/simdjson/internal/jsonformatutils.h include/simdjson/jsonioutil.h include/simdjson/jsonparser.h include/simdjson/padded_string.h include/simdjson/inline/padded_string.h include/simdjson/document.h include/simdjson/inline/document.h include/simdjson/parsedjson_iterator.h include/simdjson/inline/parsedjson_iterator.h include/simdjson/document_stream.h include/simdjson/inline/document_stream.h include/simdjson/implementation.h include/simdjson/parsedjson.h include/simdjson/portability.h include/simdjson/error.h include/simdjson/inline/error.h include/simdjson/simdjson.h include/simdjson/simdjson_version.h
-
-ifeq ($(SIMDJSON_TEST_AMALGAMATED_HEADERS),1)
-	HEADERS=singleheader/simdjson.h
-	LIBFILES=singleheader/simdjson.cpp
-	CXXFLAGS += -Isingleheader
-else
-	HEADERS=$(INCLUDEHEADERS) $(SRCHEADERS)
-	LIBFILES=src/simdjson.cpp
-	CXXFLAGS += -Isrc -Iinclude
-endif
-
-# We put EXTRAFLAGS after all other CXXFLAGS so they can override if necessary
-CXXFLAGS += $(EXTRAFLAGS)
-
-FEATURE_JSON_FILES=jsonexamples/generated/0-structurals-full.json jsonexamples/generated/0-structurals-miss.json jsonexamples/generated/0-structurals.json jsonexamples/generated/15-structurals-full.json jsonexamples/generated/15-structurals-miss.json jsonexamples/generated/15-structurals.json jsonexamples/generated/23-structurals-full.json jsonexamples/generated/23-structurals-miss.json jsonexamples/generated/23-structurals.json jsonexamples/generated/7-structurals-full.json jsonexamples/generated/7-structurals-miss.json jsonexamples/generated/7-structurals.json jsonexamples/generated/escape-full.json jsonexamples/generated/escape-miss.json jsonexamples/generated/escape.json jsonexamples/generated/utf-8-full.json jsonexamples/generated/utf-8-miss.json jsonexamples/generated/utf-8.json
-
-RAPIDJSON_INCLUDE:=dependencies/rapidjson/include
-SAJSON_INCLUDE:=dependencies/sajson/include
-JSON11_INCLUDE:=dependencies/json11/json11.hpp
-FASTJSON_INCLUDE:=dependencies/include/fastjson/fastjson.h
-GASON_INCLUDE:=dependencies/gason/src/gason.h
-UJSON4C_INCLUDE:=dependencies/ujson4c/src/ujdecode.c
-CJSON_INCLUDE:=dependencies/cJSON/cJSON.h
-JSMN_INCLUDE:=dependencies/jsmn/jsmn.h
-JSON_INCLUDE:=dependencies/json/single_include/nlohmann/json.hpp
-
-EXTRAOBJECTS=ujdecode.o
-
-MAINEXECUTABLES=parse minify json2json jsonstats statisticalmodel jsonpointer get_corpus_benchmark
-TESTEXECUTABLES=jsoncheck jsoncheck_westmere jsoncheck_fallback integer_tests numberparsingcheck stringparsingcheck pointercheck parse_many_test basictests errortests readme_examples readme_examples_noexceptions
-COMPARISONEXECUTABLES=minifiercompetition parsingcompetition parseandstatcompetition distinctuseridcompetition allparserscheckfile allparsingcompetition
-SUPPLEMENTARYEXECUTABLES=parse_noutf8validation parse_nonumberparsing parse_nostringparsing
-
-all:  $(MAINEXECUTABLES)
-
-competition:  $(COMPARISONEXECUTABLES)
-
-.PHONY: benchmark test
-
-benchmark:
-	bash ./scripts/parser.sh
-	bash ./scripts/parseandstat.sh
-
-run_basictests: basictests
-	./basictests
-
-run_errortests: errortests
-	./errortests
-
-run_numberparsingcheck: numberparsingcheck
-	./numberparsingcheck
-
-run_integer_tests: integer_tests
-	./integer_tests
-
-run_stringparsingcheck: stringparsingcheck
-	./stringparsingcheck
-
-run_jsoncheck: jsoncheck
-	./jsoncheck
-
-run_parse_many_test: parse_many_test
-	./parse_many_test
-
-run_jsoncheck_westmere: jsoncheck_westmere
-	./jsoncheck_westmere
-
-run_jsoncheck_fallback: jsoncheck_fallback
-	./jsoncheck_fallback
-
-run_pointercheck: pointercheck
-	./pointercheck
-
-run_issue150_sh: allparserscheckfile
-	./scripts/issue150.sh
-
-quickstart:
-	cd examples/quickstart && make quickstart
-
-run_quickstart:
-	cd examples/quickstart && make test
-
-run_testjson2json_sh: minify json2json
-	./scripts/testjson2json.sh
-
-$(FEATURE_JSON_FILES): benchmark/genfeaturejson.rb
-	ruby ./benchmark/genfeaturejson.rb
-
-run_benchfeatures: benchfeatures $(FEATURE_JSON_FILES)
-	./benchfeatures -n 1000
-
-test: quicktests slowtests
-	@echo "It looks like the code is good!"
-
-quiettest: quicktests slowtests
-
-quicktests: run_basictests run_quickstart readme_examples readme_examples_noexceptions run_jsoncheck run_numberparsingcheck run_integer_tests run_stringparsingcheck run_jsoncheck run_parse_many_test run_pointercheck run_jsoncheck_westmere run_jsoncheck_fallback
-
-slowtests: run_testjson2json_sh run_issue150_sh
-
-amalgamate:
-	./amalgamation.sh
-
-singleheader/simdjson.h singleheader/simdjson.cpp singleheader/amalgamation_demo.cpp: amalgamation.sh src/simdjson.cpp $(SRCHEADERS) $(INCLUDEHEADERS)
-	./amalgamation.sh
-
-singleheader/demo: singleheader/simdjson.h singleheader/simdjson.cpp singleheader/amalgamation_demo.cpp
-	$(CXX) $(CXXFLAGS) -o singleheader/demo singleheader/amalgamation_demo.cpp -Isingleheader
-
-submodules:
-	-git submodule update --init --recursive
-	-touch submodules
-
-$(JSON_INCLUDE) $(SAJSON_INCLUDE) $(RAPIDJSON_INCLUDE) $(JSON11_INCLUDE) $(FASTJSON_INCLUDE) $(GASON_INCLUDE) $(UJSON4C_INCLUDE) $(CJSON_INCLUDE) $(JSMN_INCLUDE) : submodules
-
-parse: benchmark/parse.cpp benchmark/event_counter.h benchmark/benchmarker.h $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o parse benchmark/parse.cpp $(LIBFILES) $(LIBFLAGS)
-
-get_corpus_benchmark: benchmark/get_corpus_benchmark.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o get_corpus_benchmark benchmark/get_corpus_benchmark.cpp $(LIBFILES) $(LIBFLAGS)
-
-parse_stream: benchmark/parse_stream.cpp benchmark/event_counter.h benchmark/benchmarker.h $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o parse_stream benchmark/parse_stream.cpp $(LIBFILES) $(LIBFLAGS)
-
-benchfeatures: benchmark/benchfeatures.cpp benchmark/event_counter.h benchmark/benchmarker.h $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o benchfeatures benchmark/benchfeatures.cpp $(LIBFILES) $(LIBFLAGS)
-
-perfdiff: benchmark/perfdiff.cpp
-	$(CXX) $(CXXFLAGS) -o perfdiff benchmark/perfdiff.cpp $(LIBFILES) $(LIBFLAGS)
-
-checkperf:
-	bash ./scripts/checkperf.sh $(REFERENCE_VERSION)
-
-statisticalmodel: benchmark/statisticalmodel.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o statisticalmodel benchmark/statisticalmodel.cpp $(LIBFILES) $(LIBFLAGS)
-
-
-parse_noutf8validation: benchmark/parse.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o parse_noutf8validation -DSIMDJSON_SKIPUTF8VALIDATION benchmark/parse.cpp $(LIBFILES) $(LIBFLAGS)
-
-parse_nonumberparsing: benchmark/parse.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o parse_nonumberparsing  -DSIMDJSON_SKIPNUMBERPARSING benchmark/parse.cpp $(LIBFILES) $(LIBFLAGS)
-
-parse_nostringparsing: benchmark/parse.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o parse_nostringparsing  -DSIMDJSON_SKIPSTRINGPARSING benchmark/parse.cpp $(LIBFILES) $(LIBFLAGS)
-
-
-jsoncheck:tests/jsoncheck.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o jsoncheck tests/jsoncheck.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-parse_many_test:tests/parse_many_test.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o parse_many_test tests/parse_many_test.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-
-jsoncheck_westmere:tests/jsoncheck.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o jsoncheck_westmere tests/jsoncheck.cpp -I. $(LIBFILES) $(LIBFLAGS) -DSIMDJSON_IMPLEMENTATION_HASWELL=0
-
-jsoncheck_fallback:tests/jsoncheck.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o jsoncheck_fallback tests/jsoncheck.cpp -I. $(LIBFILES) $(LIBFLAGS) -DSIMDJSON_IMPLEMENTATION_HASWELL=0 -DSIMDJSON_IMPLEMENTATION_WESTMERE=0 -DSIMDJSON_IMPLEMENTATION_ARM64=0
-
-basictests:tests/basictests.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o basictests tests/basictests.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-errortests:tests/errortests.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o errortests tests/errortests.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-readme_examples: tests/readme_examples.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o readme_examples tests/readme_examples.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-readme_examples_noexceptions: tests/readme_examples_noexceptions.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o readme_examples_noexceptions tests/readme_examples_noexceptions.cpp -I. $(LIBFILES) $(LIBFLAGS) -fno-exceptions
-
-numberparsingcheck: tests/numberparsingcheck.cpp $(HEADERS) src/simdjson.cpp
-	$(CXX) $(CXXFLAGS) -o numberparsingcheck tests/numberparsingcheck.cpp -I. $(LIBFLAGS) -DJSON_TEST_NUMBERS
-
-integer_tests:tests/integer_tests.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o integer_tests tests/integer_tests.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-
-
-stringparsingcheck: tests/stringparsingcheck.cpp $(HEADERS) src/simdjson.cpp
-	$(CXX) $(CXXFLAGS) -o stringparsingcheck tests/stringparsingcheck.cpp -I. $(LIBFLAGS) -DJSON_TEST_STRINGS
-
-pointercheck:tests/pointercheck.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o pointercheck tests/pointercheck.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-minifiercompetition: benchmark/minifiercompetition.cpp submodules $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o minifiercompetition benchmark/minifiercompetition.cpp -I. $(LIBFILES) $(LIBFLAGS) $(COREDEPSINCLUDE)
-
-minify: tools/minify.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o minify tools/minify.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-json2json: tools/json2json.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o json2json $ tools/json2json.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-jsonpointer: tools/jsonpointer.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o jsonpointer $ tools/jsonpointer.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-jsonstats: tools/jsonstats.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o jsonstats $ tools/jsonstats.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-ujdecode.o: $(UJSON4C_INCLUDE)
-	$(CC) $(CFLAGS) -c dependencies/ujson4c/src/ujdecode.c
-
-parseandstatcompetition: benchmark/parseandstatcompetition.cpp $(HEADERS) $(LIBFILES) submodules
-	$(CXX) $(CXXFLAGS) -o parseandstatcompetition benchmark/parseandstatcompetition.cpp -I. $(LIBFILES) $(LIBFLAGS) $(COREDEPSINCLUDE)
-
-distinctuseridcompetition: benchmark/distinctuseridcompetition.cpp $(HEADERS) $(LIBFILES) submodules
-	$(CXX) $(CXXFLAGS) -o distinctuseridcompetition benchmark/distinctuseridcompetition.cpp  -I. $(LIBFILES) $(LIBFLAGS) $(COREDEPSINCLUDE)
-
-parsingcompetition: benchmark/parsingcompetition.cpp $(HEADERS) $(LIBFILES) submodules
-	@echo "In case of build error due to missing files, try 'make clean'"
-	$(CXX) $(CXXFLAGS) -o parsingcompetition benchmark/parsingcompetition.cpp -I. $(LIBFILES) $(LIBFLAGS) $(COREDEPSINCLUDE)
-
-allparsingcompetition: benchmark/parsingcompetition.cpp $(HEADERS) $(LIBFILES) $(EXTRAOBJECTS) submodules
-	$(CXX) $(CXXFLAGS) -o allparsingcompetition benchmark/parsingcompetition.cpp  $(EXTRAOBJECTS) -I. $(LIBFILES) $(LIBFLAGS) $(COREDEPSINCLUDE) $(EXTRADEPSINCLUDE)  -DALLPARSER
-
-
-allparserscheckfile: tests/allparserscheckfile.cpp $(HEADERS) $(LIBFILES) $(EXTRAOBJECTS) submodules
-	$(CXX) $(CXXFLAGS) -o allparserscheckfile tests/allparserscheckfile.cpp $(EXTRAOBJECTS) -I. $(LIBFILES) $(LIBFLAGS) $(COREDEPSINCLUDE) $(EXTRADEPSINCLUDE)
-
-.PHONY:  clean cppcheck cleandist
-
-cppcheck:
-	cppcheck --enable=all src/*.cpp  benchmarks/*.cpp tests/*.cpp -Iinclude -I. -Ibenchmark/linux
-
-everything: $(MAINEXECUTABLES) $(EXTRA_EXECUTABLES) $(TESTEXECUTABLES) $(COMPARISONEXECUTABLES) $(SUPPLEMENTARYEXECUTABLES) quickstart
-
-clean:
-	rm -f submodules $(EXTRAOBJECTS) $(MAINEXECUTABLES) $(EXTRA_EXECUTABLES) $(TESTEXECUTABLES) $(COMPARISONEXECUTABLES) $(SUPPLEMENTARYEXECUTABLES)
-	cd examples/quickstart && make clean
-
-cleandist:
-	rm -f submodules $(EXTRAOBJECTS) $(MAINEXECUTABLES) $(EXTRA_EXECUTABLES) $(TESTEXECUTABLES) $(COMPARISONEXECUTABLES) $(SUPPLEMENTARYEXECUTABLES)
-
-doc/api: Doxyfile $(HEADERS)
-	doxygen
@@ -1,8 +1,9 @@
-[![Build Status](https://cloud.drone.io/api/badges/simdjson/simdjson/status.svg)](https://cloud.drone.io/simdjson/simdjson)
-[![CircleCI](https://circleci.com/gh/simdjson/simdjson.svg?style=svg)](https://circleci.com/gh/simdjson/simdjson)
 [![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/simdjson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&q=proj%3Asimdjson&can=2)
-[![Build status](https://ci.appveyor.com/api/projects/status/ae77wp5v3lebmu6n/branch/master?svg=true)](https://ci.appveyor.com/project/lemire/simdjson-jmmti/branch/master)
-[![][license img]][license]
+![Ubuntu 18.04 CI](https://github.com/simdjson/simdjson/workflows/Ubuntu%2018.04%20CI%20(GCC%207)/badge.svg)
+[![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.6.0/index.html)

 simdjson : Parsing gigabytes of JSON per second
 ===============================================
@@ -10,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.

@@ -39,7 +43,7 @@ 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.
+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.
 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
@@ -54,7 +58,7 @@ The simdjson library is easily consumable with a single .h and .cpp file.
     std::cout << tweets["search_metadata"]["count"] << " results." << std::endl;
   }
   ```
-3. `c++ -o quickstart quickstart.cpp simdjson.cpp -std=c++17`
+3. `c++ -o quickstart quickstart.cpp simdjson.cpp`
 4. `./quickstart`
   ```
   100 results.
@@ -69,20 +73,19 @@ 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.3.0/annotated.html) contains the automatically generated API documentation.
+* [API](https://simdjson.org/api/0.6.0/annotated.html) contains the automatically generated API documentation.

 Performance results
 -------------------

-The simdjson library uses three-quarters less instructions than state-of-the-art parser RapidJSON and
+The simdjson library uses three-quarters less instructions than state-of-the-art parser [RapidJSON](https://rapidjson.org) and
 fifty percent less than sajson. To our knowledge, simdjson is the first fully-validating JSON parser
-to run at gigabytes per second on commodity processors. It can parse millions of JSON documents
-per second on a single core.
+to run at [gigabytes per second](https://en.wikipedia.org/wiki/Gigabyte) (GB/s) on commodity processors. It can parse millions of JSON documents per second on a single core.

 The following figure represents parsing speed in GB/s for parsing various files
 on an Intel Skylake processor (3.4 GHz) using the GNU GCC 9 compiler (with the -O3 flag).
 We compare against the best and fastest C++ libraries.
-The simdjson library offers full unicode (UTF-8) validation and exact
+The simdjson library offers full unicode ([UTF-8](https://en.wikipedia.org/wiki/UTF-8)) validation and exact
 number parsing. The RapidJSON library is tested in two modes: fast and
 exact number parsing. The sajson library offers fast (but not exact)
 number parsing and partial unicode validation. In this data set, the file
@@ -119,15 +122,21 @@ 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
 ----------------

 - [Microsoft FishStore](https://github.com/microsoft/FishStore)
 - [Yandex ClickHouse](https://github.com/yandex/ClickHouse)
 - [Clang Build Analyzer](https://github.com/aras-p/ClangBuildAnalyzer)
+- [Shopify HeapProfiler](https://github.com/Shopify/heap-profiler)

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

@@ -137,6 +146,7 @@ Bindings and Ports of simdjson
 We distinguish between "bindings" (which just wrap the C++ code) and a port to another programming language (which reimplements everything).

 - [ZippyJSON](https://github.com/michaeleisel/zippyjson): Swift bindings for the simdjson project.
+- [libpy_simdjson](https://github.com/gerrymanoim/libpy_simdjson/): high-speed Python bindings for simdjson using [libpy](https://github.com/quantopian/libpy).
 - [pysimdjson](https://github.com/TkTech/pysimdjson): Python bindings for the simdjson project.
 - [simdjson-rs](https://github.com/simd-lite): Rust port.
 - [simdjson-rust](https://github.com/SunDoge/simdjson-rust): Rust wrapper (bindings).
@@ -144,8 +154,11 @@ We distinguish between "bindings" (which just wrap the C++ code) and a port to a
 - [simdjson_nodejs](https://github.com/luizperes/simdjson_nodejs): Node.js bindings for the simdjson project.
 - [simdjson_php](https://github.com/crazyxman/simdjson_php): PHP bindings for the simdjson project.
 - [simdjson_ruby](https://github.com/saka1/simdjson_ruby): Ruby bindings for the simdjson project.
+- [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
 --------------
@@ -155,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/).

@@ -167,7 +184,8 @@ For the video inclined, <br />
 Funding
 -------

-The work is supported by the Natural Sciences and Engineering Research Council of Canada under grant number RGPIN-2017-03910.
+The work is supported by the Natural Sciences and Engineering Research Council of Canada under grant
+number RGPIN-2017-03910.

 [license]: LICENSE
 [license img]: https://img.shields.io/badge/License-Apache%202-blue.svg
@@ -181,6 +199,8 @@ Head over to [CONTRIBUTING.md](CONTRIBUTING.md) for information on contributing
 License
 -------

-This code is made available under the Apache License 2.0.
+This code is made available under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html).

 Under Windows, we build some tools using the windows/dirent_portable.h file (which is outside our library code): it under the liberal (business-friendly) MIT license.
+
+For compilers that do not support [C++17](https://en.wikipedia.org/wiki/C%2B%2B17), we bundle the string-view library which is published under the Boost license (http://www.boost.org/LICENSE_1_0.txt). Like the Apache license, the Boost license is a permissive license allowing commercial redistribution.
@@ -1,3 +1,39 @@
+# 0.5
+
+## Highlights
+
+Performance
+* Faster and simpler UTF-8 validation with the lookup4 algorithm https://github.com/simdjson/simdjson/pull/993
+* We improved the performance of simdjson under Visual Studio by about 25%. Users will still get better performance with clang-cl (+30%) but the gap has been reduced. https://github.com/simdjson/simdjson/pull/1031
+
+Code usability
+* In `parse_many`, when parsing streams of JSON documetns, we give to the users runtime control as to whether threads are used (via the parser.threaded attribute). https://github.com/simdjson/simdjson/issues/925
+* Prefixed public macros to avoid name clashes with other libraries. https://github.com/simdjson/simdjson/issues/1035
+* Better documentation regarding package managers (brew, MSYS2, conan, apt, vcpkg, FreeBSD package manager, etc.).
+* Better documentation regarding  CMake usage.
+
+Standards
+* We improved standard compliance with respect to both the JSON RFC 8259 and JSON Pointer RFC 6901. We added the at_pointer method to nodes for standard-compliant JSON Pointer queries. The legacy `at(std::string_view)` method remains but is deprecated since it is not standard-compliant as per  RFC 6901.
+* We removed computed GOTOs without sacrificing performance thus improving the C++ standard compliance (since computed GOTOs are compiler-specific extensions).
+* Better support for C++20 https://github.com/simdjson/simdjson/pull/1050
+
+# 0.4
+
+## Highlights
+
+- Test coverage has been greatly improved and we have resolved many static-analysis warnings on different systems.
+- We added a fast (8GB/s) minifier that works directly on JSON strings.
+- We added fast (10GB/s) UTF-8 validator that works directly on strings (any strings, including non-JSON).
+- The array and object elements have a constant-time size() method.
+- Performance improvements to the API (type(), get<>()).
+- The parse_many function (ndjson) has been entirely reworked. It now uses a single secondary thread instead of several new threads.
+- We have introduced a faster UTF-8 validation algorithm (lookup3) for all kernels (ARM, x64 SSE, x64 AVX).
+- C++11 support for older compilers and systems.
+- FreeBSD support (and tests).
+- We support the clang front-end compiler (clangcl) under Visual Studio.
+- It is now possible to target ARM platforms under Visual Studio.
+- The simdjson library will never abort or print to standard output/error.
+
 # 0.3

 ## Highlights
@@ -1,185 +0,0 @@
-#!/bin/bash
-########################################################################
-# Generates an "amalgamation build" for roaring. Inspired by similar
-# script used by whefs.
-########################################################################
-SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
-
-echo "We are about to amalgamate all simdjson files into one source file. "
-echo "See https://www.sqlite.org/amalgamation.html and https://en.wikipedia.org/wiki/Single_Compilation_Unit for rationale. "
-
-AMAL_H="simdjson.h"
-AMAL_C="simdjson.cpp"
-
-SRCPATH="$SCRIPTPATH/src"
-INCLUDEPATH="$SCRIPTPATH/include"
-
-# this list excludes the "src/generic headers"
-ALLCFILES="
-simdjson.cpp
-"
-
-# order matters
-ALLCHEADERS="
-simdjson.h
-"
-
-found_includes=()
-
-for file in ${ALLCFILES}; do
-    test -e "$SRCPATH/$file" && continue
-    echo "FATAL: source file [$SRCPATH/$file] not found."
-    exit 127
-done
-
-for file in ${ALLCHEADERS}; do
-    test -e "$INCLUDEPATH/$file" && continue
-    echo "FATAL: source file [$INCLUDEPATH/$file] not found."
-    exit 127
-done
-
-function doinclude()
-{
-    file=$1
-    line="${@:2}"
-    if [ -f $INCLUDEPATH/$file ]; then
-        if [[ ! " ${found_includes[@]} " =~ " ${file} " ]]; then
-            found_includes+=("$file")
-            dofile $INCLUDEPATH/$file
-        fi;
-    elif [ -f $SRCPATH/$file ]; then
-        # generic includes are included multiple times
-        if [[ "${file}" == *'generic/'*'.h' ]]; then
-            dofile $SRCPATH/$file
-        elif [[ ! " ${found_includes[@]} " =~ " ${file} " ]]; then
-            found_includes+=("$file")
-            dofile $SRCPATH/$file
-        else
-            echo "/* $file already included: $line */"
-        fi
-    else
-      # If we don't recognize it, just emit the #include
-      echo "$line"
-    fi
-}
-
-function dofile()
-{
-    # Last lines are always ignored. Files should end by an empty lines.
-    RELFILE=${1#"$SCRIPTPATH/"}
-    echo "/* begin file $RELFILE */"
-    # echo "#line 8 \"$1\"" ## redefining the line/file is not nearly as useful as it sounds for debugging. It breaks IDEs.
-    while IFS= read -r line || [ -n "$line" ];
-    do
-        if [[ "${line}" == '#include "'*'"'* ]]; then
-            file=$(echo $line| cut -d'"' -f 2)
-
-            if [[ "${file}" == '../'* ]]; then
-                file=$(echo $file| cut -d'/' -f 2-)
-            fi;
-
-            # we explicitly include simdjson headers, one time each (unless they are generic, in which case multiple times is fine)
-            doinclude $file $line
-        else
-            # Otherwise we simply copy the line
-            echo "$line"
-        fi
-    done < "$1"
-    echo "/* end file $RELFILE */"
-}
-timestamp=$(date)
-echo "Creating ${AMAL_H}..."
-echo "/* auto-generated on ${timestamp}. Do not edit! */" > "${AMAL_H}"
-{
-    for h in ${ALLCHEADERS}; do
-        doinclude $h "ERROR $h not found"
-    done
-} >> "${AMAL_H}"
-
-
-echo "Creating ${AMAL_C}..."
-echo "/* auto-generated on ${timestamp}. Do not edit! */" > "${AMAL_C}"
-{
-    echo "#include \"${AMAL_H}\""
-
-    echo ""
-    echo "/* used for http://dmalloc.com/ Dmalloc - Debug Malloc Library */"
-    echo "#ifdef DMALLOC"
-    echo "#include \"dmalloc.h\""
-    echo "#endif"
-    echo ""
-
-    for file in ${ALLCFILES}; do
-        dofile "$SRCPATH/$file"
-    done
-} >> "${AMAL_C}"
-
-
-DEMOCPP="amalgamation_demo.cpp"
-echo "Creating ${DEMOCPP}..."
-echo "/* auto-generated on ${timestamp}. Do not edit! */" > "${DEMOCPP}"
-cat <<< '
-#include <iostream>
-#include "simdjson.h"
-#include "simdjson.cpp"
-int main(int argc, char *argv[]) {
-  if(argc < 2) {
-    std::cerr << "Please specify at least one file name. " << std::endl;
-  }
-  const char * filename = argv[1];
-  simdjson::dom::parser parser;
-  auto [doc, error] = parser.load(filename); // do the parsing
-  if (error) {
-    std::cout << "parse failed" << std::endl;
-    std::cout << "error code: " << error << std::endl;
-    std::cout << error << std::endl;
-  } else {
-    std::cout << "parse valid" << std::endl;
-  }
-  if(argc == 2) {
-    return EXIT_SUCCESS;
-  }
-
-  // parse_many
-  const char * filename2 = argv[2];
-  for (auto result : parser.load_many(filename2)) {
-    error = result.error();
-  }
-  if (error) {
-    std::cout << "parse_many failed" << std::endl;
-    std::cout << "error code: " << error << std::endl;
-    std::cout << error << std::endl;
-  } else {
-    std::cout << "parse_many valid" << std::endl;
-  }
-  return EXIT_SUCCESS;
-}
-' >>  "${DEMOCPP}"
-
-echo "Done with all files generation. "
-
-echo "Files have been written to  directory: $PWD "
-ls -la ${AMAL_C} ${AMAL_H}  ${DEMOCPP}
-
-echo "Giving final instructions:"
-
-
-CPPBIN=${DEMOCPP%%.*}
-
-echo "Try :"
-echo "c++ -O3 -std=c++17 -pthread -o ${CPPBIN} ${DEMOCPP}  && ./${CPPBIN} ../jsonexamples/twitter.json ../jsonexamples/amazon_cellphones.ndjson"
-
-SINGLEHDR=$SCRIPTPATH/singleheader
-echo "Copying files to $SCRIPTPATH/singleheader "
-mkdir -p $SINGLEHDR
-echo "c++ -O3 -std=c++17 -pthread -o ${CPPBIN} ${DEMOCPP}  && ./${CPPBIN} ../jsonexamples/twitter.json ../jsonexamples/amazon_cellphones.ndjson" > $SINGLEHDR/README.md
-cp ${AMAL_C} ${AMAL_H}  ${DEMOCPP} $SINGLEHDR
-ls $SINGLEHDR
-
-cd $SINGLEHDR && c++ -O3 -std=c++17 -pthread -o ${CPPBIN} ${DEMOCPP}  && ./${CPPBIN} ../jsonexamples/twitter.json ../jsonexamples/amazon_cellphones.ndjson
-
-lowercase(){
-    echo "$1" | tr 'A-Z' 'a-z'
-}
-
-OS=`lowercase \`uname\``
@@ -1,21 +1,50 @@
-target_include_directories(${SIMDJSON_LIB_NAME}
-  INTERFACE
-  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/benchmark>
-  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/benchmark/linux>
-)
+include_directories( . linux )
+link_libraries(simdjson-windows-headers test-data)

-add_cpp_benchmark(parse)
-add_cpp_benchmark(statisticalmodel)
-add_cpp_benchmark(parse_stream)
-add_cpp_benchmark(get_corpus_benchmark)
+
+if (TARGET benchmark::benchmark)
+  add_executable(bench_sax bench_sax.cpp)
+  target_link_libraries(bench_sax simdjson-internal-flags simdjson-include-source benchmark::benchmark)
+endif (TARGET benchmark::benchmark)
+
+link_libraries(simdjson simdjson-flags)
+add_executable(benchfeatures benchfeatures.cpp)
+add_executable(get_corpus_benchmark get_corpus_benchmark.cpp)
 add_executable(perfdiff perfdiff.cpp)
+add_executable(parse parse.cpp)
+add_executable(parse_stream parse_stream.cpp)
+add_executable(statisticalmodel statisticalmodel.cpp)

-# Google Benchmarks
-if (SIMDJSON_GOOGLE_BENCHMARKS)
-  add_cpp_benchmark(bench_parse_call)
-  target_link_libraries(bench_parse_call benchmark::benchmark)
+add_executable(parse_noutf8validation parse.cpp)
+target_compile_definitions(parse_noutf8validation PRIVATE SIMDJSON_SKIPUTF8VALIDATION)
+add_executable(parse_nonumberparsing parse.cpp)
+target_compile_definitions(parse_nonumberparsing PRIVATE SIMDJSON_SKIPNUMBERPARSING)
+add_executable(parse_nostringparsing parse.cpp)
+target_compile_definitions(parse_nostringparsing PRIVATE SIMDJSON_SKIPSTRINGPARSING)

-  add_cpp_benchmark(bench_dom_api)
-  target_link_libraries(bench_dom_api benchmark::benchmark)
-  target_compile_definitions(bench_dom_api PRIVATE JSON_TEST_PATH="${PROJECT_SOURCE_DIR}/jsonexamples/twitter.json")
-endif()
+if (TARGET competition-all)
+  add_executable(distinctuseridcompetition distinctuseridcompetition.cpp)
+  target_link_libraries(distinctuseridcompetition competition-core)
+
+  add_executable(minifiercompetition minifiercompetition.cpp)
+  target_link_libraries(minifiercompetition competition-core)
+
+  add_executable(parseandstatcompetition parseandstatcompetition.cpp)
+  target_link_libraries(parseandstatcompetition competition-core)
+
+  add_executable(parsingcompetition parsingcompetition.cpp)
+  target_link_libraries(parsingcompetition competition-core)
+
+  add_executable(allparsingcompetition parsingcompetition.cpp)
+  target_link_libraries(allparsingcompetition competition-all)
+  target_compile_definitions(allparsingcompetition PRIVATE ALLPARSER)
+endif()
+
+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)
@@ -6,19 +6,466 @@ using namespace simdjson;
 using namespace benchmark;
 using namespace std;

-#ifndef JSON_TEST_PATH
-#define JSON_TEST_PATH "jsonexamples/twitter.json"
-#endif
-
 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 void recover_one_string(State& state) {
+  dom::parser parser;
+  const std::string_view data = "\"one string\"";
+  padded_string docdata{data};
+  // we do not want mem. alloc. in the loop.
+  auto error = parser.allocate(docdata.size());
+  if(error) {
+      cout << error << endl;
+      return;
+  }
+  dom::element doc;
+  if ((error = parser.parse(docdata).get(doc))) {
+    cerr << "could not parse string" << error << endl;
+    return;
+  }
+  for (simdjson_unused auto _ : state) {
+      std::string_view v;
+      error = doc.get(v);
+      if (error) {
+        cerr << "could not get string" << error << endl;
+        return;
+      }
+      benchmark::DoNotOptimize(v);
+  }
+}
+BENCHMARK(recover_one_string);
+
+
+static void serialize_twitter(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) {
+    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_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;
+  dom::array arr;
+  simdjson::error_code error;
+  if ((error = parser.load(NUMBERS_JSON).get(arr))) {
+    cerr << "could not read " << NUMBERS_JSON << " as an array: " << error << endl;
+    return;
+  }
+  for (simdjson_unused auto _ : state) {
+    std::vector<double> container;
+    for (auto e : arr) {
+      double x;
+      if ((error = e.get(x))) { cerr << "found a node that is not an number: " << error << endl; break;}
+      container.push_back(x);
+    }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }  
+}
+BENCHMARK(numbers_scan);
+
+static void numbers_size_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr;
+  simdjson::error_code error;
+  if ((error = parser.load(NUMBERS_JSON).get(arr))) {
+    cerr << "could not read " << NUMBERS_JSON << " as an array: " << error << endl;
+    return;
+  }
+  for (simdjson_unused auto _ : state) {
+    std::vector<double> container;
+    container.resize(arr.size());
+    size_t pos = 0;
+    for (auto e : arr) {
+      double x;
+      if ((error = e.get(x))) { cerr << "found a node that is not an number: " << error << endl; break;}
+      container[pos++] = x;
+    }
+    if(pos != container.size()) { cerr << "bad count" << endl; }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }  
+}
+BENCHMARK(numbers_size_scan);
+
+
+static void numbers_type_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr;
+  simdjson::error_code error;
+  if ((error = parser.load(NUMBERS_JSON).get(arr))) {
+    cerr << "could not read " << NUMBERS_JSON << " as an array" << endl;
+    return;
+  }
+  for (simdjson_unused auto _ : state) {
+    std::vector<double> container;
+    for (auto e : arr) {
+      dom::element_type actual_type = e.type();
+      if(actual_type != dom::element_type::DOUBLE) {
+        cerr << "found a node that is not an number?" << endl; break;
+      }
+      double x;
+      error = e.get(x);
+      container.push_back(x);
+    }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_type_scan);
+
+static void numbers_type_size_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr;
+  simdjson::error_code error;
+  if ((error = parser.load(NUMBERS_JSON).get(arr))) {
+    cerr << "could not read " << NUMBERS_JSON << " as an array: " << error << endl;
+    return;
+  }
+  for (simdjson_unused auto _ : state) {
+    std::vector<double> container;
+    container.resize(arr.size());
+    size_t pos = 0;
+    for (auto e : arr) {
+      dom::element_type actual_type = e.type();
+      if(actual_type != dom::element_type::DOUBLE) {
+        cerr << "found a node that is not an number?" << endl; break;
+      }
+      double x;
+      error = e.get(x);
+      container[pos++] = x;
+    }
+    if(pos != container.size()) { cerr << "bad count" << endl; }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_type_size_scan);
+
+static void numbers_load_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr;
+  simdjson::error_code error;
+  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;
+      break;
+    }
+    std::vector<double> container;
+    for (auto e : arr) {
+      double x;
+      if ((error = e.get(x))) { cerr << "found a node that is not an number: " << error << endl; break;}
+      container.push_back(x);
+    }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }  
+}
+BENCHMARK(numbers_load_scan);
+
+static void numbers_load_size_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr;
+  simdjson::error_code error;
+  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;
+      break;
+    }
+    std::vector<double> container;
+    container.resize(arr.size());
+    size_t pos = 0;
+    for (auto e : arr) {
+      double x;
+      if ((error = e.get(x))) { cerr << "found a node that is not an number?" << endl; break;}
+      container[pos++] = x;
+    }
+    if(pos != container.size()) { cerr << "bad count" << endl; }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }  
+}
+BENCHMARK(numbers_load_size_scan);
+
+
 #if SIMDJSON_EXCEPTIONS

+
+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) {
+    std::vector<double> container;
+    for (double x : arr) {
+      container.push_back(x);
+    }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }  
+}
+BENCHMARK(numbers_exceptions_scan);
+
+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) {
+    std::vector<double> container;
+    container.resize(arr.size());
+    size_t pos = 0;
+    for (auto e : arr) {
+      container[pos++] = double(e);
+    }
+    if(pos != container.size()) { cerr << "bad count" << endl; }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }  
+}
+BENCHMARK(numbers_exceptions_size_scan);
+
+
+
+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) {
+    std::vector<double> container;
+    for (auto e : arr) {
+      dom::element_type actual_type = e.type();
+      if(actual_type != dom::element_type::DOUBLE) {
+        cerr << "found a node that is not an number?" << endl; break;
+      }
+      container.push_back(double(e));
+    }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_type_exceptions_scan);
+
+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) {
+    std::vector<double> container;
+    container.resize(arr.size());
+    size_t pos = 0;
+    for (auto e : arr) {
+      dom::element_type actual_type = e.type();
+      if(actual_type != dom::element_type::DOUBLE) {
+        cerr << "found a node that is not an number?" << endl; break;
+      }
+      container[pos++] = double(e);
+    }
+    if(pos != container.size()) { cerr << "bad count" << endl; }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+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) {
+    // this may hit the disk, but probably just once
+    dom::array arr = parser.load(NUMBERS_JSON);
+    std::vector<double> container;
+    for (double x : arr) {
+      container.push_back(x);
+    }
+    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) {
+    // this may hit the disk, but probably just once
+    dom::array arr = parser.load(NUMBERS_JSON);
+    std::vector<double> container;
+    container.resize(arr.size());
+    size_t pos = 0;
+    for (double x : arr) {
+      container[pos++] = x;
+    }
+    if(pos != container.size()) { cerr << "bad count" << endl; }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }  
+}
+BENCHMARK(numbers_exceptions_load_size_scan);
+
+
 static void twitter_count(State& state) {
  // Prints the number of results in twitter.json
  dom::parser parser;
-  dom::element doc = parser.load(JSON_TEST_PATH);
-  for (auto _ : state) {
+  dom::element doc = parser.load(TWITTER_JSON);
+  for (simdjson_unused auto _ : state) {
    uint64_t result_count = doc["search_metadata"]["count"];
    if (result_count != 100) { return; }
  }
@@ -29,9 +476,9 @@ 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(JSON_TEST_PATH);
+  padded_string json = padded_string::load(TWITTER_JSON);
  ParsedJson pj = build_parsed_json(json);
-  for (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; }
@@ -48,10 +495,10 @@ SIMDJSON_POP_DISABLE_WARNINGS
 static void twitter_default_profile(State& state) {
  // Count unique users with a default profile.
  dom::parser parser;
-  dom::element doc = parser.load(JSON_TEST_PATH);
-  for (auto _ : state) {
+  dom::element doc = parser.load(TWITTER_JSON);
+  for (simdjson_unused auto _ : state) {
    set<string_view> default_users;
-    for (dom::object tweet : doc["statuses"].get<dom::array>()) {
+    for (dom::object tweet : doc["statuses"]) {
      dom::object user = tweet["user"];
      if (user["default_profile"]) {
        default_users.insert(user["screen_name"]);
@@ -65,15 +512,16 @@ BENCHMARK(twitter_default_profile);
 static void twitter_image_sizes(State& state) {
  // Count unique image sizes
  dom::parser parser;
-  dom::element doc = parser.load(JSON_TEST_PATH);
-  for (auto _ : state) {
+  dom::element doc = parser.load(TWITTER_JSON);
+  simdjson::error_code error;
+  for (simdjson_unused auto _ : state) {
    set<tuple<uint64_t, uint64_t>> image_sizes;
-    for (dom::object tweet : doc["statuses"].get<dom::array>()) {
-      auto [media, not_found] = tweet["entities"]["media"];
-      if (!not_found) {
-        for (dom::object image : media.get<dom::array>()) {
-          for (auto [key, size] : image["sizes"].get<dom::object>()) {
-            image_sizes.insert({ size["w"], size["h"] });
+    for (dom::object tweet : doc["statuses"]) {
+      dom::array media;
+      if (not (error = tweet["entities"]["media"].get(media))) {
+        for (dom::object image : media) {
+          for (auto size : image["sizes"].get<dom::object>()) {
+            image_sizes.insert({ size.value["w"], size.value["h"] });
          }
        }
      }
@@ -88,10 +536,12 @@ BENCHMARK(twitter_image_sizes);
 static void error_code_twitter_count(State& state) noexcept {
  // Prints the number of results in twitter.json
  dom::parser parser;
-  dom::element doc = parser.load(JSON_TEST_PATH);
-  for (auto _ : state) {
-    auto [value, error] = doc["search_metadata"]["count"].get<uint64_t>();
-    if (error) { return; }
+  simdjson::error_code error;
+  dom::element doc;
+  if ((error = parser.load(TWITTER_JSON).get(doc))) { return; }
+  for (simdjson_unused auto _ : state) {
+    uint64_t value;
+    if ((error = doc["search_metadata"]["count"].get(value))) { return; }
    if (value != 100) { return; }
  }
 }
@@ -100,20 +550,22 @@ BENCHMARK(error_code_twitter_count);
 static void error_code_twitter_default_profile(State& state) noexcept {
  // Count unique users with a default profile.
  dom::parser parser;
-  dom::element doc = parser.load(JSON_TEST_PATH);
-  for (auto _ : state) {
+  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) {
    set<string_view> default_users;

-    auto [tweets, error] = doc["statuses"].get<dom::array>();
-    if (error) { return; }
+    dom::array tweets;
+    if ((error = doc["statuses"].get(tweets))) { return; }
    for (dom::element tweet : tweets) {
-      auto [user, error2] = tweet["user"].get<dom::object>();
-      if (error2) { return; }
-      auto [default_profile, error3] = user["default_profile"].get<bool>();
-      if (error3) { return; }
+      dom::object user;
+      if ((error = tweet["user"].get(user))) { return; }
+      bool default_profile;
+      if ((error = user["default_profile"].get(default_profile))) { return; }
      if (default_profile) {
-        auto [screen_name, error4] = user["screen_name"].get<std::string_view>();
-        if (error4) { return; }
+        std::string_view screen_name;
+        if ((error = user["screen_name"].get(screen_name))) { return; }
        default_users.insert(screen_name);
      }
    }
@@ -127,13 +579,15 @@ 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 = padded_string::load(JSON_TEST_PATH);
+  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 (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    set<string_view> default_users;
    ParsedJson::Iterator iter(pj);

-    // for (dom::object tweet : doc["statuses"].get<dom::array>()) {
+    // for (dom::object tweet : doc["statuses"]) {
    if (!(iter.move_to_key("statuses") && iter.is_array())) { return; }
    if (iter.down()) { // first status
      do {
@@ -167,21 +621,23 @@ BENCHMARK(iterator_twitter_default_profile);
 static void error_code_twitter_image_sizes(State& state) noexcept {
  // Count unique image sizes
  dom::parser parser;
-  dom::element doc = parser.load(JSON_TEST_PATH);
-  for (auto _ : state) {
+  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) {
    set<tuple<uint64_t, uint64_t>> image_sizes;
-    auto [statuses, error] = doc["statuses"].get<dom::array>();
-    if (error) { return; }
+    dom::array statuses;
+    if ((error = doc["statuses"].get(statuses))) { return; }
    for (dom::element tweet : statuses) {
-      auto [images, not_found] = tweet["entities"]["media"].get<dom::array>();
-      if (!not_found) {
+      dom::array images;
+      if (not (error = tweet["entities"]["media"].get(images))) {
        for (dom::element image : images) {
-          auto [sizes, error2] = image["sizes"].get<dom::object>();
-          if (error2) { return; }
-          for (auto [key, size] : sizes) {
-            auto [width, error3] = size["w"].get<uint64_t>();
-            auto [height, error4] = size["h"].get<uint64_t>();
-            if (error3 || error4) { return; }
+          dom::object sizes;
+          if ((error = image["sizes"].get(sizes))) { return; }
+          for (auto size : sizes) {
+            uint64_t width, height;
+            if ((error = size.value["w"].get(width))) { return; }
+            if ((error = size.value["h"].get(height))) { return; }
            image_sizes.insert({ width, height });
          }
        }
@@ -196,29 +652,32 @@ SIMDJSON_PUSH_DISABLE_WARNINGS
 SIMDJSON_DISABLE_DEPRECATED_WARNING
 static void iterator_twitter_image_sizes(State& state) {
  // Count unique image sizes
-  padded_string json = padded_string::load(JSON_TEST_PATH);
+  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 (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    set<tuple<uint64_t, uint64_t>> image_sizes;
    ParsedJson::Iterator iter(pj);

-    // for (dom::object tweet : doc["statuses"].get<dom::array>()) {
+    // for (dom::object tweet : doc["statuses"]) {
    if (!(iter.move_to_key("statuses") && iter.is_array())) { return; }
    if (iter.down()) { // first status
      do {

-        // auto [media, not_found] = tweet["entities"]["media"];
+        // dom::object media;
+        // not_found = tweet["entities"]["media"].get(media);
        // if (!not_found) {
        if (iter.move_to_key("entities")) {
          if (!iter.is_object()) { return; }
          if (iter.move_to_key("media")) {
            if (!iter.is_array()) { return; }

-            //   for (dom::object image : media.get<dom::array>()) {
+            //   for (dom::object image : media) {
            if (iter.down()) { // first media
              do {

-                // for (auto [key, size] : image["sizes"].get<dom::object>()) {
+                // for (auto [key, size] : dom::object(image["sizes"])) {
                if (!(iter.move_to_key("sizes") && iter.is_object())) { return; }
                if (iter.down()) { // first size
                  do {
@@ -254,10 +713,15 @@ BENCHMARK(iterator_twitter_image_sizes);

 static void print_json(State& state) noexcept {
  // Prints the number of results in twitter.json
-  padded_string json = get_corpus(JSON_TEST_PATH);
  dom::parser parser;
-  if (int error = json_parse(json, parser); error != SUCCESS) { cerr << error_message(error) << endl; return; }
-  for (auto _ : state) {
+
+  padded_string json;
+  auto error = padded_string::load(TWITTER_JSON).get(json);
+  if (error) { std::cerr << error << std::endl; return; }
+
+  int code = json_parse(json, parser);
+  if (code) { cerr << error_message(code) << endl; return; }
+  for (simdjson_unused auto _ : state) {
    std::stringstream s;
    if (!parser.print_json(s)) { cerr << "print_json failed" << endl; return; }
  }
@@ -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();
@@ -5,13 +5,118 @@ using namespace benchmark;
 using namespace std;

 const padded_string EMPTY_ARRAY("[]", 2);
+const char *TWITTER_JSON = SIMDJSON_BENCHMARK_DATA_DIR "twitter.json";
+const char *GSOC_JSON = SIMDJSON_BENCHMARK_DATA_DIR "gsoc-2018.json";
+
+
+
+static void unicode_validate_twitter(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.
+  error = parser.allocate(docdata.size());
+  if(error) {
+      cout << error << endl;
+      return;
+  }
+  size_t bytes = 0;
+  for (simdjson_unused auto _ : state) {
+    bool is_ok = simdjson::validate_utf8(docdata.data(), docdata.size());
+    bytes += docdata.size();
+    benchmark::DoNotOptimize(is_ok);
+  }
+  // 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(unicode_validate_twitter)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+static void parse_twitter(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.
+  error = parser.allocate(docdata.size());
+  if(error) {
+      cout << error << endl;
+      return;
+  }
+  size_t bytes = 0;
+  for (simdjson_unused auto _ : state) {
+    dom::element doc;
+    bytes += docdata.size();
+    if ((error = parser.parse(docdata).get(doc))) {
+      cerr << "could not parse twitter.json" << error << endl;
+      return;
+    }
+    benchmark::DoNotOptimize(doc);
+  }
+  // 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(parse_twitter)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+
+static void parse_gsoc(State& state) {
+  dom::parser parser;
+  padded_string docdata;
+  auto error = padded_string::load(GSOC_JSON).get(docdata);
+  if(error) {
+      cerr << "could not parse gsoc-2018.json" << error << endl;
+      return;
+  }
+  // we do not want mem. alloc. in the loop.
+  error = parser.allocate(docdata.size());
+  if(error) {
+      cout << error << endl;
+      return;
+  }
+  size_t bytes = 0;
+  for (simdjson_unused auto _ : state) {
+    bytes += docdata.size();
+    dom::element doc;
+    if ((error = parser.parse(docdata).get(doc))) {
+      cerr << "could not parse gsoc-2018.json" << error << endl;
+      return;
+    }
+    benchmark::DoNotOptimize(doc);
+  }
+  // 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(parse_gsoc)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+

 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 (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    auto error = json_parse(EMPTY_ARRAY, pj);
    if (error) { return; }
  }
@@ -21,53 +126,66 @@ BENCHMARK(json_parse);
 static void parser_parse_error_code(State& state) {
  dom::parser parser;
  if (parser.allocate(EMPTY_ARRAY.length())) { return; }
-  for (auto _ : state) {
-    auto [doc, error] = parser.parse(EMPTY_ARRAY);
+  for (simdjson_unused auto _ : state) {
+    auto error = parser.parse(EMPTY_ARRAY).error();
    if (error) { return; }
  }
 }
 BENCHMARK(parser_parse_error_code);
+
+#if SIMDJSON_EXCEPTIONS
+
 static void parser_parse_exception(State& state) {
  dom::parser parser;
  if (parser.allocate(EMPTY_ARRAY.length())) { return; }
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    try {
-      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;
    }
  }
 }
 BENCHMARK(parser_parse_exception);

+#endif // SIMDJSON_EXCEPTIONS
+
 SIMDJSON_PUSH_DISABLE_WARNINGS
 SIMDJSON_DISABLE_DEPRECATED_WARNING
 static void build_parsed_json(State& state) {
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    dom::parser parser = simdjson::build_parsed_json(EMPTY_ARRAY);
    if (!parser.valid) { return; }
  }
 }
 SIMDJSON_POP_DISABLE_WARNINGS
+
 BENCHMARK(build_parsed_json);
 static void document_parse_error_code(State& state) {
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    dom::parser parser;
-    auto [doc, error] = parser.parse(EMPTY_ARRAY);
+    auto error = parser.parse(EMPTY_ARRAY).error();
    if (error) { return; }
  }
 }
 BENCHMARK(document_parse_error_code);
+
+#if SIMDJSON_EXCEPTIONS
+
 static void document_parse_exception(State& state) {
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
    try {
      dom::parser parser;
-      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;
    }
  }
 }
 BENCHMARK(document_parse_exception);

-BENCHMARK_MAIN();
+#endif // SIMDJSON_EXCEPTIONS
+
+BENCHMARK_MAIN();
@@ -0,0 +1,14 @@
+#include "simdjson.h"
+#include "simdjson.cpp"
+#include <iostream>
+#include <sstream>
+#include <random>
+#include <vector>
+SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
+#include <benchmark/benchmark.h>
+SIMDJSON_POP_DISABLE_WARNINGS
+
+#include "partial_tweets/sax.h"
+#include "largerandom/sax.h"
+
+BENCHMARK_MAIN();
@@ -4,8 +4,8 @@
 #include <cctype>
 #ifndef _MSC_VER
 #include <dirent.h>
-#include <unistd.h>
 #endif
+#include <unistd.h>
 #include <cinttypes>
 #include <initializer_list>

@@ -75,7 +75,6 @@ void exit_usage(string message) {
 }

 struct option_struct {
-  architecture arch = architecture::UNSUPPORTED;
  bool stage1_only = false;

  int32_t iterations = 400;
@@ -84,48 +83,41 @@ struct option_struct {
  bool verbose = false;

  option_struct(int argc, char **argv) {
-    #ifndef _MSC_VER
-      int c;
+    int c;

-      while ((c = getopt(argc, argv, "vtn:i:a:s:")) != -1) {
-        switch (c) {
-        case 'n':
-          iterations = atoi(optarg);
-          break;
-        case 'i':
-          iteration_step = atoi(optarg);
-          break;
-        case 'v':
-          verbose = true;
-          break;
-        case 'a':
-          arch = parse_architecture(optarg);
-          if (arch == architecture::UNSUPPORTED) {
-            exit_usage(string("Unsupported option value -a ") + optarg + ": expected -a HASWELL, WESTMERE or ARM64");
+    while ((c = getopt(argc, argv, "vtn:i:a:s:")) != -1) {
+      switch (c) {
+      case 'n':
+        iterations = atoi(optarg);
+        break;
+      case 'i':
+        iteration_step = atoi(optarg);
+        break;
+      case 'v':
+        verbose = true;
+        break;
+      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")) {
-            stage1_only = true;
-          } else if (!strcmp(optarg, "all")) {
-            stage1_only = false;
-          } else {
-            exit_usage(string("Unsupported option value -s ") + optarg + ": expected -s stage1 or all");
-          }
-          break;
-        default:
-          exit_error("Unexpected argument " + c);
+        } 
+        break;
+      case 's':
+        if (!strcmp(optarg, "stage1")) {
+          stage1_only = true;
+        } else if (!strcmp(optarg, "all")) {
+          stage1_only = false;
+        } else {
+          exit_usage(string("Unsupported option value -s ") + optarg + ": expected -s stage1 or all");
        }
+        break;
+      default:
+        exit_error(string("Unexpected argument ") + std::string(1,static_cast<char>(c)));
      }
-    #else
-      int optind = 1;
-    #endif
-
-    // If architecture is not specified, pick the best supported architecture by default
-    if (arch == architecture::UNSUPPORTED) {
-      arch = find_best_supported_architecture();
    }
-    dom::parser::use_implementation(arch);
  }

  template<typename F>
@@ -154,25 +146,25 @@ struct feature_benchmarker {
  benchmarker struct23;
  benchmarker struct23_miss;

-  feature_benchmarker(const simdjson::implementation &parser, event_collector& collector) :
-    utf8               ("jsonexamples/generated/utf-8.json", parser, collector),
-    utf8_miss          ("jsonexamples/generated/utf-8-miss.json", parser, collector),
-    escape               ("jsonexamples/generated/escape.json", parser, collector),
-    escape_miss          ("jsonexamples/generated/escape-miss.json", parser, collector),
-    empty              ("jsonexamples/generated/0-structurals.json", parser, collector),
-    empty_miss         ("jsonexamples/generated/0-structurals-miss.json", parser, collector),
-    struct7           ("jsonexamples/generated/7-structurals.json", parser, collector),
-    struct7_miss      ("jsonexamples/generated/7-structurals-miss.json", parser, collector),
-    struct7_full       ("jsonexamples/generated/7-structurals-full.json", parser, collector),
-    struct15     ("jsonexamples/generated/15-structurals.json", parser, collector),
-    struct15_miss("jsonexamples/generated/15-structurals-miss.json", parser, collector),
-    struct23     ("jsonexamples/generated/23-structurals.json", parser, collector),
-    struct23_miss("jsonexamples/generated/23-structurals-miss.json", parser, collector)
+  feature_benchmarker(event_collector& collector) :
+    utf8               (SIMDJSON_BENCHMARK_DATA_DIR "generated/utf-8.json", collector),
+    utf8_miss          (SIMDJSON_BENCHMARK_DATA_DIR "generated/utf-8-miss.json", collector),
+    escape               (SIMDJSON_BENCHMARK_DATA_DIR "generated/escape.json", collector),
+    escape_miss          (SIMDJSON_BENCHMARK_DATA_DIR "generated/escape-miss.json", collector),
+    empty              (SIMDJSON_BENCHMARK_DATA_DIR "generated/0-structurals.json", collector),
+    empty_miss         (SIMDJSON_BENCHMARK_DATA_DIR "generated/0-structurals-miss.json", collector),
+    struct7           (SIMDJSON_BENCHMARK_DATA_DIR "generated/7-structurals.json", collector),
+    struct7_miss      (SIMDJSON_BENCHMARK_DATA_DIR "generated/7-structurals-miss.json", collector),
+    struct7_full       (SIMDJSON_BENCHMARK_DATA_DIR "generated/7-structurals-full.json", collector),
+    struct15     (SIMDJSON_BENCHMARK_DATA_DIR "generated/15-structurals.json", collector),
+    struct15_miss(SIMDJSON_BENCHMARK_DATA_DIR "generated/15-structurals-miss.json", collector),
+    struct23     (SIMDJSON_BENCHMARK_DATA_DIR "generated/23-structurals.json", collector),
+    struct23_miss(SIMDJSON_BENCHMARK_DATA_DIR "generated/23-structurals-miss.json", collector)
  {

  }

-  really_inline void run_iterations(size_t iterations, bool stage1_only=false) {
+  simdjson_really_inline void run_iterations(size_t iterations, bool stage1_only=false) {
    struct7.run_iterations(iterations, stage1_only);
    struct7_miss.run_iterations(iterations, stage1_only);
    struct7_full.run_iterations(iterations, stage1_only);
@@ -189,7 +181,7 @@ struct feature_benchmarker {
  }

  double cost_per_block(BenchmarkStage stage, const benchmarker& feature, size_t feature_blocks, const benchmarker& base) const {
-    return (feature[stage].best.elapsed_ns() - base[stage].best.elapsed_ns()) / feature_blocks;
+    return (feature[stage].best.elapsed_ns() - base[stage].best.elapsed_ns()) / double(feature_blocks);
  }

  // Whether we're recording cache miss and branch miss events
@@ -199,7 +191,7 @@ struct feature_benchmarker {

  // Base cost of any block (including empty ones)
  double base_cost(BenchmarkStage stage) const {
-    return (empty[stage].best.elapsed_ns() / empty.stats->blocks);
+    return (empty[stage].best.elapsed_ns() / double(empty.stats->blocks));
  }

  // Extra cost of a 1-7 structural block over an empty block
@@ -213,7 +205,7 @@ struct feature_benchmarker {
  // Rate of 1-7-structural misses per 8-structural flip
  double struct1_7_miss_rate(BenchmarkStage stage) const {
    if (!has_events()) { return 1; }
-    return double(struct7_miss[stage].best.branch_misses() - struct7[stage].best.branch_misses()) / struct7_miss.stats->blocks_with_1_structural_flipped;
+    return struct7_miss[stage].best.branch_misses() - struct7[stage].best.branch_misses() / double(struct7_miss.stats->blocks_with_1_structural_flipped);
  }

  // Extra cost of an 8-15 structural block over a 1-7 structural block
@@ -227,7 +219,7 @@ struct feature_benchmarker {
  // Rate of 8-15-structural misses per 8-structural flip
  double struct8_15_miss_rate(BenchmarkStage stage) const {
    if (!has_events()) { return 1; }
-    return double(struct15_miss[stage].best.branch_misses() - struct15[stage].best.branch_misses()) / struct15_miss.stats->blocks_with_8_structurals_flipped;
+    return double(struct15_miss[stage].best.branch_misses() - struct15[stage].best.branch_misses()) / double(struct15_miss.stats->blocks_with_8_structurals_flipped);
  }

  // Extra cost of a 16+-structural block over an 8-15 structural block (actual varies based on # of structurals!)
@@ -241,7 +233,7 @@ struct feature_benchmarker {
  // Rate of 16-structural misses per 16-structural flip
  double struct16_miss_rate(BenchmarkStage stage) const {
    if (!has_events()) { return 1; }
-    return double(struct23_miss[stage].best.branch_misses() - struct23[stage].best.branch_misses()) / struct23_miss.stats->blocks_with_16_structurals_flipped;
+    return double(struct23_miss[stage].best.branch_misses() - struct23[stage].best.branch_misses()) / double(struct23_miss.stats->blocks_with_16_structurals_flipped);
  }

  // Extra cost of having UTF-8 in a block
@@ -255,7 +247,7 @@ struct feature_benchmarker {
  // Rate of UTF-8 misses per UTF-8 flip
  double utf8_miss_rate(BenchmarkStage stage) const {
    if (!has_events()) { return 1; }
-    return double(utf8_miss[stage].best.branch_misses() - utf8[stage].best.branch_misses()) / utf8_miss.stats->blocks_with_utf8_flipped;
+    return double(utf8_miss[stage].best.branch_misses() - utf8[stage].best.branch_misses()) / double(utf8_miss.stats->blocks_with_utf8_flipped);
  }

  // Extra cost of having escapes in a block
@@ -269,39 +261,39 @@ struct feature_benchmarker {
  // Rate of escape misses per escape flip
  double escape_miss_rate(BenchmarkStage stage) const {
    if (!has_events()) { return 1; }
-    return double(escape_miss[stage].best.branch_misses() - escape[stage].best.branch_misses()) / escape_miss.stats->blocks_with_escapes_flipped;
+    return double(escape_miss[stage].best.branch_misses() - escape[stage].best.branch_misses()) / double(escape_miss.stats->blocks_with_escapes_flipped);
  }

  double calc_expected_feature_cost(BenchmarkStage stage, const benchmarker& file) const {
    // Expected base ns/block (empty)
    json_stats& stats = *file.stats;
-    double expected = base_cost(stage)       * stats.blocks;
-    expected +=       struct1_7_cost(stage)  * stats.blocks_with_1_structural;
-    expected +=       utf8_cost(stage)       * stats.blocks_with_utf8;
-    expected +=       escape_cost(stage)     * stats.blocks_with_escapes;
-    expected +=       struct8_15_cost(stage) * stats.blocks_with_8_structurals;
-    expected +=       struct16_cost(stage)   * stats.blocks_with_16_structurals;
-    return expected / stats.blocks;
+    double expected = base_cost(stage)       * double(stats.blocks);
+    expected +=       struct1_7_cost(stage)  * double(stats.blocks_with_1_structural);
+    expected +=       utf8_cost(stage)       * double(stats.blocks_with_utf8);
+    expected +=       escape_cost(stage)     * double(stats.blocks_with_escapes);
+    expected +=       struct8_15_cost(stage) * double(stats.blocks_with_8_structurals);
+    expected +=       struct16_cost(stage)   * double(stats.blocks_with_16_structurals);
+    return expected / double(stats.blocks);
  }

  double calc_expected_miss_cost(BenchmarkStage stage, const benchmarker& file) const {
    // Expected base ns/block (empty)
    json_stats& stats = *file.stats;
-    double expected = struct1_7_miss_cost(stage)  * stats.blocks_with_1_structural_flipped * struct1_7_miss_rate(stage);
-    expected +=       utf8_miss_cost(stage)       * stats.blocks_with_utf8_flipped * utf8_miss_rate(stage);
-    expected +=       escape_miss_cost(stage)     * stats.blocks_with_escapes_flipped * escape_miss_rate(stage);
-    expected +=       struct8_15_miss_cost(stage) * stats.blocks_with_8_structurals_flipped * struct8_15_miss_rate(stage);
-    expected +=       struct16_miss_cost(stage)   * stats.blocks_with_16_structurals_flipped * struct16_miss_rate(stage);
-    return expected / stats.blocks;
+    double expected = struct1_7_miss_cost(stage)  * double(stats.blocks_with_1_structural_flipped) * struct1_7_miss_rate(stage);
+    expected +=       utf8_miss_cost(stage)       * double(stats.blocks_with_utf8_flipped) * utf8_miss_rate(stage);
+    expected +=       escape_miss_cost(stage)     * double(stats.blocks_with_escapes_flipped) * escape_miss_rate(stage);
+    expected +=       struct8_15_miss_cost(stage) * double(stats.blocks_with_8_structurals_flipped) * struct8_15_miss_rate(stage);
+    expected +=       struct16_miss_cost(stage)   * double(stats.blocks_with_16_structurals_flipped) * struct16_miss_rate(stage);
+    return expected / double(stats.blocks);
  }

  double calc_expected_misses(BenchmarkStage stage, const benchmarker& file) const {
    json_stats& stats = *file.stats;
-    double expected = stats.blocks_with_1_structural_flipped   * struct1_7_miss_rate(stage);
-    expected +=       stats.blocks_with_utf8_flipped           * utf8_miss_rate(stage);
-    expected +=       stats.blocks_with_escapes_flipped        * escape_miss_rate(stage);
-    expected +=       stats.blocks_with_8_structurals_flipped  * struct8_15_miss_rate(stage);
-    expected +=       stats.blocks_with_16_structurals_flipped * struct16_miss_rate(stage);
+    double expected = double(stats.blocks_with_1_structural_flipped)   * struct1_7_miss_rate(stage);
+    expected +=       double(stats.blocks_with_utf8_flipped)           * utf8_miss_rate(stage);
+    expected +=       double(stats.blocks_with_escapes_flipped)        * escape_miss_rate(stage);
+    expected +=       double(stats.blocks_with_8_structurals_flipped)  * struct8_15_miss_rate(stage);
+    expected +=       double(stats.blocks_with_16_structurals_flipped) * struct16_miss_rate(stage);
    return expected;
  }

@@ -368,10 +360,10 @@ struct feature_benchmarker {
 };

 void print_file_effectiveness(BenchmarkStage stage, const char* filename, const benchmarker& results, const feature_benchmarker& features) {
-  double actual = results[stage].best.elapsed_ns() / results.stats->blocks;
+  double actual = results[stage].best.elapsed_ns() / double(results.stats->blocks);
  double calc = features.calc_expected(stage, results);
-  uint64_t actual_misses = results[stage].best.branch_misses();
-  uint64_t calc_misses = uint64_t(features.calc_expected_misses(stage, results));
+  double actual_misses = results[stage].best.branch_misses();
+  double calc_misses = features.calc_expected_misses(stage, results);
  double calc_miss_cost = features.calc_expected_miss_cost(stage, results);
  printf("        | %-8s ", benchmark_stage_name(stage));
  printf("| %-15s ",   filename);
@@ -380,10 +372,10 @@ void print_file_effectiveness(BenchmarkStage stage, const char* filename, const
  printf("| %8.3g ",  calc);
  printf("| %8.3g ",  actual);
  printf("| %+8.3g ", actual - calc);
-  printf("| %13lu ",  calc_misses);
+  printf("| %13llu ", (long long unsigned)(calc_misses));
  if (features.has_events()) {
-    printf("| %13lu ",  actual_misses);
-    printf("| %+13ld ", int64_t(actual_misses - calc_misses));
+    printf("| %13llu ", (long long unsigned)(actual_misses));
+    printf("| %+13lld ", (long long int)(actual_misses - calc_misses));
    double miss_adjustment = calc_miss_cost * (double(int64_t(actual_misses - calc_misses)) / calc_misses);
    printf("|      %8.3g ", calc_miss_cost + miss_adjustment);
    printf("|      %+8.3g ", actual - (calc + miss_adjustment));
@@ -405,9 +397,9 @@ int main(int argc, char *argv[]) {

  // Set up benchmarkers by reading all files
  feature_benchmarker features(collector);
-  benchmarker gsoc_2018("jsonexamples/gsoc-2018.json", collector);
-  benchmarker twitter("jsonexamples/twitter.json", collector);
-  benchmarker random("jsonexamples/random.json", collector);
+  benchmarker gsoc_2018(SIMDJSON_BENCHMARK_DATA_DIR "gsoc-2018.json", collector);
+  benchmarker twitter(SIMDJSON_BENCHMARK_DATA_DIR "twitter.json", collector);
+  benchmarker random(SIMDJSON_BENCHMARK_DATA_DIR "random.json", collector);

  // Run the benchmarks
  progress_bar progress(options.iterations, 100);
@@ -1,82 +1,7 @@
 #ifndef _BENCHMARK_H_
 #define _BENCHMARK_H_
-#include <float.h>
-#include <stdint.h>
-#include <time.h>
-#ifdef __x86_64__

-const char *unitname = "cycles";
-
-#define RDTSC_START(cycles)                                                    \
-  do {                                                                         \
-    uint32_t cyc_high, cyc_low;                                                \
-    __asm volatile("cpuid\n"                                                   \
-                   "rdtsc\n"                                                   \
-                   "mov %%edx, %0\n"                                           \
-                   "mov %%eax, %1"                                             \
-                   : "=r"(cyc_high), "=r"(cyc_low)                             \
-                   :                                                           \
-                   :                              /* no read only */           \
-                   "%rax", "%rbx", "%rcx", "%rdx" /* clobbers */               \
-    );                                                                         \
-    (cycles) = ((uint64_t)cyc_high << 32) | cyc_low;                           \
-  } while (0)
-
-#define RDTSC_STOP(cycles)                                                     \
-  do {                                                                         \
-    uint32_t cyc_high, cyc_low;                                                \
-    __asm volatile("rdtscp\n"                                                  \
-                   "mov %%edx, %0\n"                                           \
-                   "mov %%eax, %1\n"                                           \
-                   "cpuid"                                                     \
-                   : "=r"(cyc_high), "=r"(cyc_low)                             \
-                   : /* no read only registers */                              \
-                   : "%rax", "%rbx", "%rcx", "%rdx" /* clobbers */             \
-    );                                                                         \
-    (cycles) = ((uint64_t)cyc_high << 32) | cyc_low;                           \
-  } while (0)
-
-#else
-const char *unitname = " (clock units) ";
-
-#define RDTSC_START(cycles)                                                    \
-  do {                                                                         \
-    cycles = clock();                                                          \
-  } while (0)
-
-#define RDTSC_STOP(cycles)                                                     \
-  do {                                                                         \
-    cycles = clock();                                                          \
-  } while (0)
-#endif
-
-static __attribute__((noinline)) uint64_t rdtsc_overhead_func(uint64_t dummy) {
-  return dummy;
-}
-
-uint64_t global_rdtsc_overhead = (uint64_t)UINT64_MAX;
-
-#define RDTSC_SET_OVERHEAD(test, repeat)                                       \
-  do {                                                                         \
-    uint64_t cycles_start, cycles_final, cycles_diff;                          \
-    uint64_t min_diff = UINT64_MAX;                                            \
-    for (int i = 0; i < repeat; i++) {                                         \
-      __asm volatile("" ::: /* pretend to clobber */ "memory");                \
-      RDTSC_START(cycles_start);                                               \
-      test;                                                                    \
-      RDTSC_STOP(cycles_final);                                                \
-      cycles_diff = (cycles_final - cycles_start);                             \
-      if (cycles_diff < min_diff)                                              \
-        min_diff = cycles_diff;                                                \
-    }                                                                          \
-    global_rdtsc_overhead = min_diff;                                          \
-  } while (0)
-
-double diff(timespec start, timespec end) {
-  return ((end.tv_nsec + 1000000000 * end.tv_sec) -
-          (start.tv_nsec + 1000000000 * start.tv_sec)) /
-         1000000000.0;
-}
+#include "event_counter.h"

 /*
 * Prints the best number of operations per cycle where
@@ -86,142 +11,99 @@ double diff(timespec start, timespec end) {
 */
 #define BEST_TIME(name, test, expected, pre, repeat, size, verbose)            \
  do {                                                                         \
-    if (global_rdtsc_overhead == UINT64_MAX) {                                 \
-      RDTSC_SET_OVERHEAD(rdtsc_overhead_func(1), repeat);                      \
-    }                                                                          \
    if (verbose)                                                               \
-      printf("%-40s\t: ", name);                                               \
+      std::printf("%-40s\t: ", name);                                          \
    else                                                                       \
-      printf("\"%-40s\"", name);                                               \
+      std::printf("\"%-40s\"", name);                                          \
    fflush(NULL);                                                              \
-    uint64_t cycles_start, cycles_final, cycles_diff;                          \
-    uint64_t min_diff = (uint64_t)-1;                                          \
-    double min_sumclockdiff = DBL_MAX;                                         \
-    uint64_t sum_diff = 0;                                                     \
-    double sumclockdiff = 0;                                                   \
-    struct timespec time1, time2;                                              \
-    for (int i = 0; i < repeat; i++) {                                         \
+    event_collector collector;                                                 \
+    event_aggregate aggregate{};                                               \
+    for (decltype(repeat) i = 0; i < repeat; i++) {                            \
      pre;                                                                     \
-      __asm volatile("" ::: /* pretend to clobber */ "memory");                \
-      clock_gettime(CLOCK_REALTIME, &time1);                                   \
-      RDTSC_START(cycles_start);                                               \
+      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;                                                                 \
      }                                                                        \
-      RDTSC_STOP(cycles_final);                                                \
-      clock_gettime(CLOCK_REALTIME, &time2);                                   \
-      double thistiming = diff(time1, time2);                                  \
-      sumclockdiff += thistiming;                                              \
-      if (thistiming < min_sumclockdiff)                                       \
-        min_sumclockdiff = thistiming;                                         \
-      cycles_diff = (cycles_final - cycles_start - global_rdtsc_overhead);     \
-      if (cycles_diff < min_diff)                                              \
-        min_diff = cycles_diff;                                                \
-      sum_diff += cycles_diff;                                                 \
+      std::atomic_thread_fence(std::memory_order_release);                     \
+      event_count allocate_count = collector.end();                            \
+      aggregate << allocate_count;                                             \
    }                                                                          \
-    uint64_t S = size;                                                         \
-    float cycle_per_op = (min_diff) / (double)S;                               \
-    float avg_cycle_per_op = (sum_diff) / ((double)S * repeat);                \
-    double avg_gb_per_s =                                                      \
-        ((double)S * repeat) / ((sumclockdiff)*1000.0 * 1000.0 * 1000.0);      \
-    double max_gb_per_s =                                                      \
-        ((double)S) / ((min_sumclockdiff)*1000.0 * 1000.0 * 1000.0);           \
-    if (verbose)                                                               \
-      printf(" %7.3f %s per input byte (best) ", cycle_per_op, unitname);      \
-    if (verbose)                                                               \
-      printf(" %7.3f %s (avg) ", avg_cycle_per_op, unitname);                  \
-    if (verbose)                                                               \
-      printf(" %7.3f GB/s (error margin: %5.3f GB/s)", max_gb_per_s,            \
-             -avg_gb_per_s + max_gb_per_s);                                    \
-    if (verbose)                                                               \
-      printf(" %13.0f documents/s (best)", 1.0/min_sumclockdiff);             \
-    if (verbose)                                                               \
-      printf(" %13.0f documents/s (avg)", 1.0/(sumclockdiff/repeat));         \
-    if (!verbose)                                                              \
-      printf(" %20.3f %20.3f %20.3f %20.3f", cycle_per_op,                     \
-             avg_cycle_per_op - cycle_per_op, max_gb_per_s,                    \
-             -avg_gb_per_s + max_gb_per_s);                                    \
-    printf("\n");                                                              \
-    fflush(NULL);                                                              \
+    if (collector.has_events()) {                                              \
+      std::printf("%7.3f",                                                     \
+                  aggregate.best.cycles() / static_cast<double>(size));        \
+      if (verbose) {                                                           \
+        std::printf(" cycles/byte ");                                          \
+      }                                                                        \
+      std::printf("\t");                                                       \
+      std::printf("%7.3f",                                                     \
+                  aggregate.best.instructions() / static_cast<double>(size));  \
+      if (verbose) {                                                           \
+        std::printf(" instructions/byte ");                                    \
+      }                                                                        \
+      std::printf("\t");                                                       \
+    }                                                                          \
+    double gb = static_cast<double>(size) / 1000000000.0;                      \
+    std::printf("%7.3f", gb / aggregate.best.elapsed_sec());                   \
+    if (verbose) {                                                             \
+      std::printf(" GB/s ");                                                   \
+    }                                                                          \
+    std::printf("\t"); \
+    std::printf("%7.3f", 1.0 / aggregate.best.elapsed_sec());                  \
+    if (verbose) {                                                             \
+      std::printf(" documents/s ");                                            \
+    }                                                                          \
+    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 (global_rdtsc_overhead == UINT64_MAX) {                                 \
-      RDTSC_SET_OVERHEAD(rdtsc_overhead_func(1), repeat);                      \
-    }                                                                          \
    if (verbose)                                                               \
-      printf("%-40s\t: ", name);                                               \
-    fflush(NULL);                                                              \
-    uint64_t cycles_start, cycles_final, cycles_diff;                          \
-    uint64_t min_diff = (uint64_t)-1;                                          \
-    uint64_t sum_diff = 0;                                                     \
-    for (int i = 0; i < repeat; i++) {                                         \
+      std::printf("%-40s\t: ", name);                                          \
+    else                                                                       \
+      std::printf("\"%-40s\"", name);                                          \
+    std::fflush(NULL);                                                         \
+    event_collector collector;                                                 \
+    event_aggregate aggregate{};                                               \
+    for (decltype(repeat) i = 0; i < repeat; i++) {                            \
      pre;                                                                     \
-      __asm volatile("" ::: /* pretend to clobber */ "memory");                \
-      RDTSC_START(cycles_start);                                               \
+      std::atomic_thread_fence(std::memory_order_acquire);                     \
+      collector.start();                                                       \
      test;                                                                    \
-      RDTSC_STOP(cycles_final);                                                \
-      cycles_diff = (cycles_final - cycles_start - global_rdtsc_overhead);     \
-      if (cycles_diff < min_diff)                                              \
-        min_diff = cycles_diff;                                                \
-      sum_diff += cycles_diff;                                                 \
+      std::atomic_thread_fence(std::memory_order_release);                     \
+      event_count allocate_count = collector.end();                            \
+      aggregate << allocate_count;                                             \
    }                                                                          \
-    uint64_t S = size;                                                         \
-    float cycle_per_op = (min_diff) / (double)S;                               \
-    float avg_cycle_per_op = (sum_diff) / ((double)S * repeat);                \
-    if (verbose)                                                               \
-      printf(" %.3f %s per input byte (best) ", cycle_per_op, unitname);       \
-    if (verbose)                                                               \
-      printf(" %.3f %s per input byte (avg) ", avg_cycle_per_op, unitname);    \
-    if (verbose)                                                               \
-      printf("\n");                                                            \
-    if (!verbose)                                                              \
-      printf(" %.3f ", cycle_per_op);                                          \
-    fflush(NULL);                                                              \
-  } while (0)
-
-// like BEST_TIME except that we run a function to check the result
-#define BEST_TIME_CHECK(test, check, pre, repeat, size, verbose)               \
-  do {                                                                         \
-    if (global_rdtsc_overhead == UINT64_MAX) {                                 \
-      RDTSC_SET_OVERHEAD(rdtsc_overhead_func(1), repeat);                      \
-    }                                                                          \
-    if (verbose)                                                               \
-      printf("%-60s\t:\n", #test);                                             \
-    fflush(NULL);                                                              \
-    uint64_t cycles_start, cycles_final, cycles_diff;                          \
-    uint64_t min_diff = (uint64_t)-1;                                          \
-    uint64_t sum_diff = 0;                                                     \
-    for (int i = 0; i < repeat; i++) {                                         \
-      pre;                                                                     \
-      __asm volatile("" ::: /* pretend to clobber */ "memory");                \
-      RDTSC_START(cycles_start);                                               \
-      test;                                                                    \
-      RDTSC_STOP(cycles_final);                                                \
-      if (!check) {                                                            \
-        printf("error");                                                       \
-        break;                                                                 \
+    if (collector.has_events()) {                                              \
+      std::printf("%7.3f",                                                     \
+                  aggregate.best.cycles() / static_cast<double>(size));        \
+      if (verbose) {                                                           \
+        std::printf(" cycles/byte ");                                          \
      }                                                                        \
-      cycles_diff = (cycles_final - cycles_start - global_rdtsc_overhead);     \
-      if (cycles_diff < min_diff)                                              \
-        min_diff = cycles_diff;                                                \
-      sum_diff += cycles_diff;                                                 \
+      std::printf("\t");                                                       \
+      std::printf("%7.3f",                                                     \
+                  aggregate.best.instructions() / static_cast<double>(size));  \
+      if (verbose) {                                                           \
+        std::printf(" instructions/byte ");                                    \
+      }                                                                        \
+      std::printf("\t");                                                       \
    }                                                                          \
-    uint64_t S = size;                                                         \
-    float cycle_per_op = (min_diff) / (double)S;                               \
-    float avg_cycle_per_op = (sum_diff) / ((double)S * repeat);                \
-    if (verbose)                                                               \
-      printf(" %.3f cycles per operation (best) ", cycle_per_op);              \
-    if (verbose)                                                               \
-      printf("\t%.3f cycles per operation (avg) ", avg_cycle_per_op);          \
-    if (verbose)                                                               \
-      printf("\n");                                                            \
-    if (!verbose)                                                              \
-      printf(" %.3f ", cycle_per_op);                                          \
-    fflush(NULL);                                                              \
+    double gb = static_cast<double>(size) / 1000000000.0;                      \
+    std::printf("%7.3f", gb / aggregate.best.elapsed_sec());                   \
+    if (verbose) {                                                             \
+      std::printf(" GB/s ");                                                   \
+    }                                                                          \
+    std::printf("\t");                                                       \
+    std::printf("%7.3f", 1.0 / aggregate.best.elapsed_sec());                  \
+    if (verbose) {                                                             \
+      std::printf(" documents/s ");                                            \
+    }                                                                          \
+    std::printf("\n");                                                         \
+    std::fflush(NULL);                                                         \
  } while (0)

 #endif
@@ -2,13 +2,14 @@
 #define __BENCHMARKER_H

 #include "event_counter.h"
+#include "simdjson.h" // For SIMDJSON_DISABLE_DEPRECATED_WARNINGS

 #include <cassert>
 #include <cctype>
 #ifndef _MSC_VER
 #include <dirent.h>
-#include <unistd.h>
 #endif
+#include <unistd.h>
 #include <cinttypes>

 #include <cstdio>
@@ -45,6 +46,8 @@ using std::vector;
 using std::ostream;
 using std::ofstream;
 using std::exception;
+using std::min;
+using std::max;

 // Initialize "verbose" to go nowhere. We'll read options in main() and set to cout if verbose is true.
 std::ofstream dev_null;
@@ -81,7 +84,7 @@ struct json_stats {
    bytes = json.size();
    blocks = bytes / BYTES_PER_BLOCK;
    if (bytes % BYTES_PER_BLOCK > 0) { blocks++; } // Account for remainder block
-    structurals = parser.n_structural_indexes-1;
+    structurals = parser.implementation->n_structural_indexes-1;

    // Calculate stats on blocks that will trigger utf-8 if statements / mispredictions
    bool last_block_has_utf8 = false;
@@ -138,7 +141,7 @@ struct json_stats {
    for (size_t block=0; block<blocks; block++) {
      // Count structurals in the block
      int block_structurals=0;
-      while (structural < parser.n_structural_indexes && parser.structural_indexes[structural] < (block+1)*BYTES_PER_BLOCK) {
+      while (structural < parser.implementation->n_structural_indexes && parser.implementation->structural_indexes[structural] < (block+1)*BYTES_PER_BLOCK) {
        block_structurals++;
        structural++;
      }
@@ -222,8 +225,19 @@ 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 
+ * 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
+ * "memory allocation" also requires a definition. Doing "new char[size]" can
+ * do many different things depending on the system.
+ */
+
 enum class BenchmarkStage {
-  ALL,
+  ALL, // This excludes allocation
  ALLOCATE,
  STAGE1,
  STAGE2
@@ -231,7 +245,7 @@ enum class BenchmarkStage {

 const char* benchmark_stage_name(BenchmarkStage stage) {
  switch (stage) {
-    case BenchmarkStage::ALL: return "All";
+    case BenchmarkStage::ALL: return "All (Without Allocation)";
    case BenchmarkStage::ALLOCATE: return "Allocate";
    case BenchmarkStage::STAGE1: return "Stage 1";
    case BenchmarkStage::STAGE2: return "Stage 2";
@@ -241,7 +255,7 @@ const char* benchmark_stage_name(BenchmarkStage stage) {

 struct benchmarker {
  // JSON text from loading the file. Owns the memory.
-  padded_string json;
+  padded_string json{};
  // JSON filename
  const char *filename;
  // Event collector that can be turned on to measure cycles, missed branches, etc.
@@ -250,22 +264,21 @@ struct benchmarker {
  // Statistics about the JSON file independent of its speed (amount of utf-8, structurals, etc.).
  // Loaded on first parse.
  json_stats* stats;
-  // Speed and event summary for full parse (not including allocation)
-  event_aggregate all_stages;
+  // Speed and event summary for full parse (stage 1 and stage 2, but *excluding* allocation)
+  event_aggregate all_stages_without_allocation{};
  // Speed and event summary for stage 1
-  event_aggregate stage1;
+  event_aggregate stage1{};
  // Speed and event summary for stage 2
-  event_aggregate stage2;
+  event_aggregate stage2{};
  // Speed and event summary for allocation
-  event_aggregate allocate_stage;
+  event_aggregate allocate_stage{};
  // Speed and event summary for the repeatly-parsing mode
-  event_aggregate loop;
+  event_aggregate loop{};

  benchmarker(const char *_filename, event_collector& _collector)
    : filename(_filename), collector(_collector), stats(NULL) {
    verbose() << "[verbose] loading " << filename << endl;
-    simdjson::error_code error;
-    padded_string::load(filename).tie(this->json, error);
+    auto error = padded_string::load(filename).get(json);
    if (error) {
      exit_error(string("Could not load the file ") + filename);
    }
@@ -278,25 +291,29 @@ struct benchmarker {
    }
  }

+  benchmarker(const benchmarker&) = delete;
+  benchmarker& operator=(const benchmarker&) = delete;
+
  const event_aggregate& operator[](BenchmarkStage stage) const {
    switch (stage) {
-      case BenchmarkStage::ALL: return this->all_stages;
+      case BenchmarkStage::ALL: return this->all_stages_without_allocation;
      case BenchmarkStage::STAGE1: return this->stage1;
      case BenchmarkStage::STAGE2: return this->stage2;
      case BenchmarkStage::ALLOCATE: return this->allocate_stage;
-      default: exit_error("Unknown stage"); return this->all_stages;
+      default: exit_error("Unknown stage"); return this->all_stages_without_allocation;
    }
  }

  int iterations() const {
-    return all_stages.iterations;
+    return all_stages_without_allocation.iterations;
  }

-  really_inline void run_iteration(bool stage1_only, bool hotbuffers=false) {
+  simdjson_really_inline void run_iteration(bool stage1_only, bool hotbuffers=false) {
    // Allocate dom::parser
    collector.start();
    dom::parser parser;
-    error_code error = parser.allocate(json.size());
+    // We always allocate at least 64KB. Smaller allocations may actually be slower under some systems.
+    error_code error = parser.allocate(json.size() < 65536 ? 65536 : json.size());
    if (error) {
      exit_error(string("Unable to allocate_stage ") + to_string(json.size()) + " bytes for the JSON result: " + error_message(error));
    }
@@ -314,7 +331,7 @@ struct benchmarker {

    // Stage 1 (find structurals)
    collector.start();
-    error = active_implementation->stage1((const uint8_t *)json.data(), json.size(), parser, false);
+    error = parser.implementation->stage1((const uint8_t *)json.data(), json.size(), false);
    event_count stage1_count = collector.end();
    stage1 << stage1_count;
    if (error) {
@@ -324,22 +341,22 @@ struct benchmarker {
    // Stage 2 (unified machine) and the rest

    if (stage1_only) {
-      all_stages << stage1_count;
+      all_stages_without_allocation << stage1_count;
    } else {
      event_count stage2_count;
      collector.start();
-      error = active_implementation->stage2((const uint8_t *)json.data(), json.size(), parser);
+      error = parser.implementation->stage2(parser.doc);
      if (error) {
        exit_error(string("Failed to parse ") + filename + " during stage 2 parsing " + error_message(error));
      }
      stage2_count = collector.end();
      stage2 << stage2_count;
-      all_stages << allocate_count + stage1_count + stage2_count;
+      all_stages_without_allocation << stage1_count + stage2_count;
    }
    // Calculate stats the first time we parse
    if (stats == NULL) {
      if (stage1_only) { //  we need stage 2 once
-        error = active_implementation->stage2((const uint8_t *)json.data(), json.size(), parser);
+        error = parser.implementation->stage2(parser.doc);
        if (error) {
          printf("Warning: failed to parse during stage 2. Unable to acquire statistics.\n");
        }
@@ -367,43 +384,44 @@ struct benchmarker {
    loop << all_loop_count;
  }

-  really_inline void run_iterations(size_t iterations, bool stage1_only, bool hotbuffers=false) {
+  simdjson_really_inline void run_iterations(size_t iterations, bool stage1_only, bool hotbuffers=false) {
    for (size_t i = 0; i<iterations; i++) {
      run_iteration(stage1_only, hotbuffers);
    }
    run_loop(iterations);
  }

+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
  template<typename T>
  void print_aggregate(const char* prefix, const T& stage) const {
-    printf("%s%-13s: %8.4f ns per block (%6.2f%%) - %8.4f ns per byte - %8.4f ns per structural - %8.3f GB/s\n",
+    printf("%s%-13s: %8.4f ns per block (%6.2f%%) - %8.4f ns per byte - %8.4f ns per structural - %8.4f GB/s\n",
      prefix,
      "Speed",
-      stage.elapsed_ns() / stats->blocks, // per block
-      100.0 * stage.elapsed_sec() / all_stages.elapsed_sec(), // %
-      stage.elapsed_ns() / stats->bytes, // per byte
-      stage.elapsed_ns() / stats->structurals, // per structural
-      (json.size() / 1000000000.0) / stage.elapsed_sec() // GB/s
+      stage.elapsed_ns() / static_cast<double>(stats->blocks), // per block
+      percent(stage.elapsed_sec(), all_stages_without_allocation.elapsed_sec()), // %
+      stage.elapsed_ns() / static_cast<double>(stats->bytes), // per byte
+      stage.elapsed_ns() / static_cast<double>(stats->structurals), // per structural
+      (static_cast<double>(json.size()) / 1000000000.0) / stage.elapsed_sec() // GB/s
    );

    if (collector.has_events()) {
      printf("%s%-13s: %8.4f per block    (%6.2f%%) - %8.4f per byte    - %8.4f per structural    - %8.3f GHz est. frequency\n",
        prefix,
        "Cycles",
-        stage.cycles() / stats->blocks,
-        100.0 * stage.cycles() / all_stages.cycles(),
-        stage.cycles() / stats->bytes,
-        stage.cycles() / stats->structurals,
+        stage.cycles() / static_cast<double>(stats->blocks),
+        percent(stage.cycles(), all_stages_without_allocation.cycles()),
+        stage.cycles() / static_cast<double>(stats->bytes),
+        stage.cycles() / static_cast<double>(stats->structurals),
        (stage.cycles() / stage.elapsed_sec()) / 1000000000.0
      );
      printf("%s%-13s: %8.4f per block    (%6.2f%%) - %8.4f per byte    - %8.4f per structural    - %8.3f per cycle\n",
        prefix,
        "Instructions",
-        stage.instructions() / stats->blocks,
-        100.0 * stage.instructions() / all_stages.instructions(),
-        stage.instructions() / stats->bytes,
-        stage.instructions() / stats->structurals,
-        stage.instructions() / stage.cycles()
+        stage.instructions() / static_cast<double>(stats->blocks),
+        percent(stage.instructions(), all_stages_without_allocation.instructions()),
+        stage.instructions() / static_cast<double>(stats->bytes),
+        stage.instructions() / static_cast<double>(stats->structurals),
+        stage.instructions() / static_cast<double>(stage.cycles())
      );

      // NOTE: removed cycles/miss because it is a somewhat misleading stat
@@ -411,18 +429,29 @@ struct benchmarker {
        prefix,
        "Misses",
        stage.branch_misses(),
-        100.0 * stage.branch_misses() / all_stages.branch_misses(),
+        percent(stage.branch_misses(), all_stages_without_allocation.branch_misses()),
        stage.cache_misses(),
-        100.0 * stage.cache_misses() / all_stages.cache_misses(),
+        percent(stage.cache_misses(), all_stages_without_allocation.cache_misses()),
        stage.cache_references()
      );
    }
  }

-  void print(bool tabbed_output, size_t iterations) const {
+  static double percent(size_t a, size_t b) {
+    return 100.0 * static_cast<double>(a) / static_cast<double>(b);
+  }
+  static double percent(double a, double b) {
+    return 100.0 * a / b;
+  }
+
+  void print(bool tabbed_output) const {
    if (tabbed_output) {
      char* filename_copy = (char*)malloc(strlen(filename)+1);
+      SIMDJSON_PUSH_DISABLE_WARNINGS
+      SIMDJSON_DISABLE_DEPRECATED_WARNING // Validated CRT_SECURE safe here
      strcpy(filename_copy, filename);
+      SIMDJSON_POP_DISABLE_WARNINGS
+
      #if defined(__linux__)
      char* base = ::basename(filename_copy);
      #else
@@ -432,21 +461,21 @@ struct benchmarker {
        base[strlen(base)-5] = '\0';
      }

-      double gb = json.size() / 1000000000.0;
+      double gb = static_cast<double>(json.size()) / 1000000000.0;
      if (collector.has_events()) {
        printf("\"%s\"\t%f\t%f\t%f\t%f\t%f\t%f\t%f\n",
                base,
-                allocate_stage.best.cycles() / json.size(),
-                stage1.best.cycles() / json.size(),
-                stage2.best.cycles() / json.size(),
-                all_stages.best.cycles() / json.size(),
-                gb / all_stages.best.elapsed_sec(),
+                allocate_stage.best.cycles() / static_cast<double>(json.size()),
+                stage1.best.cycles() / static_cast<double>(json.size()),
+                stage2.best.cycles() / static_cast<double>(json.size()),
+                all_stages_without_allocation.best.cycles() / static_cast<double>(json.size()),
+                gb / all_stages_without_allocation.best.elapsed_sec(),
                gb / stage1.best.elapsed_sec(),
                gb / stage2.best.elapsed_sec());
      } else {
        printf("\"%s\"\t\t\t\t\t%f\t%f\t%f\n",
                base,
-                gb / all_stages.best.elapsed_sec(),
+                gb / all_stages_without_allocation.best.elapsed_sec(),
                gb / stage1.best.elapsed_sec(),
                gb / stage2.best.elapsed_sec());
      }
@@ -455,28 +484,28 @@ struct benchmarker {
      printf("\n");
      printf("%s\n", filename);
      printf("%s\n", string(strlen(filename), '=').c_str());
-      printf("%9zu blocks - %10zu bytes - %5zu structurals (%5.1f %%)\n", stats->bytes / BYTES_PER_BLOCK, stats->bytes, stats->structurals, 100.0 * stats->structurals / stats->bytes);
+      printf("%9zu blocks - %10zu bytes - %5zu structurals (%5.1f %%)\n", stats->bytes / BYTES_PER_BLOCK, stats->bytes, stats->structurals, percent(stats->structurals, stats->bytes));
      if (stats) {
        printf("special blocks with: utf8 %9zu (%5.1f %%) - escape %9zu (%5.1f %%) - 0 structurals %9zu (%5.1f %%) - 1+ structurals %9zu (%5.1f %%) - 8+ structurals %9zu (%5.1f %%) - 16+ structurals %9zu (%5.1f %%)\n",
-          stats->blocks_with_utf8, 100.0 * stats->blocks_with_utf8 / stats->blocks,
-          stats->blocks_with_escapes, 100.0 * stats->blocks_with_escapes / stats->blocks,
-          stats->blocks_with_0_structurals, 100.0 * stats->blocks_with_0_structurals / stats->blocks,
-          stats->blocks_with_1_structural, 100.0 * stats->blocks_with_1_structural / stats->blocks,
-          stats->blocks_with_8_structurals, 100.0 * stats->blocks_with_8_structurals / stats->blocks,
-          stats->blocks_with_16_structurals, 100.0 * stats->blocks_with_16_structurals / stats->blocks);
+          stats->blocks_with_utf8, percent(stats->blocks_with_utf8, stats->blocks),
+          stats->blocks_with_escapes, percent(stats->blocks_with_escapes, stats->blocks),
+          stats->blocks_with_0_structurals, percent(stats->blocks_with_0_structurals, stats->blocks),
+          stats->blocks_with_1_structural, percent(stats->blocks_with_1_structural, stats->blocks),
+          stats->blocks_with_8_structurals, percent(stats->blocks_with_8_structurals, stats->blocks),
+          stats->blocks_with_16_structurals, percent(stats->blocks_with_16_structurals, stats->blocks));
        printf("special block flips: utf8 %9zu (%5.1f %%) - escape %9zu (%5.1f %%) - 0 structurals %9zu (%5.1f %%) - 1+ structurals %9zu (%5.1f %%) - 8+ structurals %9zu (%5.1f %%) - 16+ structurals %9zu (%5.1f %%)\n",
-          stats->blocks_with_utf8_flipped, 100.0 * stats->blocks_with_utf8_flipped / stats->blocks,
-          stats->blocks_with_escapes_flipped, 100.0 * stats->blocks_with_escapes_flipped / stats->blocks,
-          stats->blocks_with_0_structurals_flipped, 100.0 * stats->blocks_with_0_structurals_flipped / stats->blocks,
-          stats->blocks_with_1_structural_flipped, 100.0 * stats->blocks_with_1_structural_flipped / stats->blocks,
-          stats->blocks_with_8_structurals_flipped, 100.0 * stats->blocks_with_8_structurals_flipped / stats->blocks,
-          stats->blocks_with_16_structurals_flipped, 100.0 * stats->blocks_with_16_structurals_flipped / stats->blocks);
+          stats->blocks_with_utf8_flipped, percent(stats->blocks_with_utf8_flipped, stats->blocks),
+          stats->blocks_with_escapes_flipped, percent(stats->blocks_with_escapes_flipped, stats->blocks),
+          stats->blocks_with_0_structurals_flipped, percent(stats->blocks_with_0_structurals_flipped, stats->blocks),
+          stats->blocks_with_1_structural_flipped, percent(stats->blocks_with_1_structural_flipped, stats->blocks),
+          stats->blocks_with_8_structurals_flipped, percent(stats->blocks_with_8_structurals_flipped, stats->blocks),
+          stats->blocks_with_16_structurals_flipped, percent(stats->blocks_with_16_structurals_flipped, stats->blocks));
      }
      printf("\n");
-      printf("All Stages\n");
-      print_aggregate("|    "   , all_stages.best);
+      printf("All Stages (excluding allocation)\n");
+      print_aggregate("|    "   , all_stages_without_allocation.best);
      // frequently, allocation is a tiny fraction of the running time so we omit it
-      if(allocate_stage.best.elapsed_sec() > 0.01 * all_stages.best.elapsed_sec()) {
+      if(allocate_stage.best.elapsed_sec() > 0.01 * all_stages_without_allocation.best.elapsed_sec()) {
        printf("|- Allocation\n");
        print_aggregate("|    ", allocate_stage.best);
      }
@@ -487,17 +516,16 @@ struct benchmarker {
      if (collector.has_events()) {
        double freq1 = (stage1.best.cycles() / stage1.best.elapsed_sec()) / 1000000000.0;
        double freq2 = (stage2.best.cycles() / stage2.best.elapsed_sec()) / 1000000000.0;
-        double freqall = (all_stages.best.cycles() / all_stages.best.elapsed_sec()) / 1000000000.0;
-        double freqmin = std::min(freq1, freq2);
-        double freqmax = std::max(freq1, freq2);
+        double freqall = (all_stages_without_allocation.best.cycles() / all_stages_without_allocation.best.elapsed_sec()) / 1000000000.0;
+        double freqmin = min(freq1, freq2);
+        double freqmax = max(freq1, freq2);
        if((freqall < 0.95 * freqmin) or (freqall > 1.05 * freqmax)) {
          printf("\nWarning: The processor frequency fluctuates in an expected way!!!\n"
-          "Expect the overall speed not to match stage 1 and stage 2 speeds.\n"
          "Range for stage 1 and stage 2 : [%.3f GHz, %.3f GHz], overall: %.3f GHz.\n",
          freqmin, freqmax, freqall);
        }
      }
-      printf("\n%.1f documents parsed per second\n", iterations/loop.best.elapsed_sec());
+      printf("\n%.1f documents parsed per second (best)\n", 1.0/static_cast<double>(all_stages_without_allocation.best.elapsed_sec()));
    }
  }
 };
@@ -0,0 +1,101 @@
+# Relevant targets:
+# checkperf-parse: builds the reference checkperf-parse, syncing reference repository if needed
+# checkperf: builds the targets needed for checkperf (parse, perfdiff, checkperf-parse)
+# update-checkperf-repo: updates the reference repository we're checking performance against
+# checkperf-repo: initialize and sync reference repository (first time only)
+# TEST checkperf: runs the actual checkperf test
+
+# 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
+  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
+  # update_myrepo - will update the repo against the origin branch (and create if needed)
+  function(sync_git_repository name dir remote branch url)
+    # This conditionally creates the git repository
+    add_custom_command(
+      OUTPUT ${dir}/.git/config
+      COMMAND ${GIT_EXECUTABLE} init ${dir}
+      COMMAND ${GIT_EXECUTABLE} -C ${dir} remote add ${remote} ${url}
+    )
+    add_custom_target(init-${name} DEPENDS ${dir}/.git/config)
+    # This conditionally syncs the git repository, first time only
+    add_custom_command(
+      OUTPUT ${dir}/.git/FETCH_HEAD
+      COMMAND ${GIT_EXECUTABLE} remote set-url ${remote} ${url}
+      COMMAND ${GIT_EXECUTABLE} fetch --depth=1 ${remote} ${branch}
+      COMMAND ${GIT_EXECUTABLE} reset --hard ${remote}/${branch}
+      WORKING_DIRECTORY ${dir}
+      DEPENDS init-${name}
+    )
+    # This is the ${name} target, which will create and sync the repo first time only
+    add_custom_target(${name} DEPENDS ${dir}/.git/FETCH_HEAD)
+    # This is the update-${name} target, which will sync the repo (creating it if needed)
+    add_custom_target(
+      update-${name}
+      COMMAND ${GIT_EXECUTABLE} remote set-url ${remote} ${url}
+      COMMAND ${GIT_EXECUTABLE} fetch --depth=1 ${remote} ${branch}
+      COMMAND ${GIT_EXECUTABLE} reset --hard ${remote}/${branch}
+      WORKING_DIRECTORY ${dir}
+      DEPENDS init-${name}
+    )
+  endfunction(sync_git_repository)
+
+  set(SIMDJSON_CHECKPERF_REMOTE origin CACHE STRING "Remote repository to compare performance against")
+  set(SIMDJSON_CHECKPERF_BRANCH master CACHE STRING "Branch to compare performance against")
+  set(SIMDJSON_CHECKPERF_DIR ${CMAKE_CURRENT_BINARY_DIR}/checkperf-reference/${SIMDJSON_CHECKPERF_BRANCH} CACHE STRING "Location to put checkperf performance comparison repository")
+  set(SIMDJSON_CHECKPERF_ARGS ${EXAMPLE_JSON} CACHE STRING "Arguments to pass to parse during checkperf")
+  sync_git_repository(checkperf-repo ${SIMDJSON_CHECKPERF_DIR} ${SIMDJSON_CHECKPERF_REMOTE} ${SIMDJSON_CHECKPERF_BRANCH} ${SIMDJSON_GITHUB_REPOSITORY})
+
+  # Commands to cause cmake on benchmark/checkperf-master/build/
+  # - first, copy CMakeCache.txt
+  add_custom_command(
+    OUTPUT ${SIMDJSON_CHECKPERF_DIR}/build/CMakeCache.txt
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${SIMDJSON_CHECKPERF_DIR}/build
+    COMMAND ${CMAKE_COMMAND} -E copy ${SIMDJSON_USER_CMAKECACHE} ${SIMDJSON_CHECKPERF_DIR}/build/CMakeCache.txt
+    DEPENDS checkperf-repo simdjson-user-cmakecache
+  )
+  # - second, cmake ..
+  add_custom_command(
+    OUTPUT ${SIMDJSON_CHECKPERF_DIR}/build/cmake_install.cmake # We make many things but this seems the most cross-platform one we can depend on
+    COMMAND
+    ${CMAKE_COMMAND} -E env CXX=${CMAKE_CXX_COMPILER} CC=${CMAKE_C_COMPILER}
+    ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_COMPETITION=OFF -G ${CMAKE_GENERATOR} ..
+    WORKING_DIRECTORY ${SIMDJSON_CHECKPERF_DIR}/build
+    DEPENDS ${SIMDJSON_CHECKPERF_DIR}/build/CMakeCache.txt
+  )
+
+  # - third, build parse.
+  if (CMAKE_CONFIGURATION_TYPES)
+    set(CHECKPERF_PARSE ${SIMDJSON_CHECKPERF_DIR}/build/benchmark/$<CONFIGURATION>/parse)
+  else()
+    set(CHECKPERF_PARSE ${SIMDJSON_CHECKPERF_DIR}/build/benchmark/parse)
+  endif()
+  add_custom_target(
+    checkperf-parse ALL # TODO is ALL necessary?
+    # Build parse
+    COMMAND ${CMAKE_COMMAND} --build . --target parse --config $<CONFIGURATION>
+    WORKING_DIRECTORY ${SIMDJSON_CHECKPERF_DIR}/build
+    DEPENDS ${SIMDJSON_CHECKPERF_DIR}/build/cmake_install.cmake # We make many things but this seems the most cross-platform one we can depend on
+  )
+
+  # Target to build everything needed for the checkperf test
+  add_custom_target(checkperf DEPENDS parse perfdiff checkperf-parse)
+
+  # Add the actual checkperf test
+  add_test(
+    NAME checkperf
+    # COMMAND ECHO $<TARGET_FILE:perfdiff> \"$<TARGET_FILE:parse> -t ${SIMDJSON_CHECKPERF_ARGS}\" \"${CHECKPERF_PARSE} -t ${SIMDJSON_CHECKPERF_ARGS}\" }
+    COMMAND $<TARGET_FILE:perfdiff> $<TARGET_FILE:parse> ${CHECKPERF_PARSE} -H -t ${SIMDJSON_CHECKPERF_ARGS}
+  )
+  set_property(TEST checkperf APPEND PROPERTY LABELS per_implementation)
+  set_property(TEST checkperf APPEND PROPERTY DEPENDS parse perfdiff ${SIMDJSON_USER_CMAKECACHE})
+  set_property(TEST checkperf PROPERTY RUN_SERIAL TRUE)
+else()
+  if (CMAKE_GENERATOR MATCHES Ninja)
+   message(STATUS "We disable the checkperf targets under Ninja.")
+  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
@@ -1,5 +1,6 @@
 #include "simdjson.h"
 #include <algorithm>
+#include <cstring>
 #include <unistd.h>
 #include <vector>

@@ -37,19 +38,20 @@ 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) {
-  if (element.is<simdjson::dom::array>()) {
-    auto [array, array_error] = element.get<simdjson::dom::array>();
+  error_code error;
+  if (element.is_array()) {
+    dom::array array;
+    error = element.get(array);
    for (auto child : array) {
      if (child.is<simdjson::dom::array>() || child.is<simdjson::dom::object>()) {
        simdjson_recurse(v, child);
      }
    }
-  } else if (element.is<simdjson::dom::object>()) {
-    auto [object, error] = element.get<simdjson::dom::object>();
+  } else if (element.is_object()) {
    int64_t id;
-    object["user"]["id"].get<int64_t>().tie(id,error);
+    error = element["user"]["id"].get(id);
    if(!error) {
      v.push_back(id);
    }
@@ -63,43 +65,50 @@ void print_vec(const std::vector<int64_t> &v) {
 // clang-format on


-void simdjson_recurse(std::vector<int64_t> & v, simdjson::dom::element element) {
-  if (element.is<simdjson::dom::array>()) {
-    auto array = element.get<simdjson::dom::array>();
-    for (auto child : array) {
-      if (child.is<simdjson::dom::array>() || child.is<simdjson::dom::object>()) {
-        simdjson_recurse(v, child);
-      }
-    }
-  } else if (element.is<simdjson::dom::object>()) {
-    auto object = element.get<simdjson::dom::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"
-        if(value.is<simdjson::dom::object>()) {
-          auto child_object = value.get<simdjson::dom::object>();
-          for (auto [child_key, child_value] : child_object) {
-            if((child_key.size() == 2) && (memcmp(child_key.data(), "id", 2) == 0)) {
-              if(child_value.is<int64_t>()) {
-                v.push_back(child_value.get<int64_t>());
-              }
+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);
            }
-            if (child_value.is<simdjson::dom::array>() || child_value.is<simdjson::dom::object>()) {
-              simdjson_recurse(v, child_value);
-            }    
          }
-        } else if (value.is<simdjson::dom::array>()) {
-          simdjson_recurse(v, value);
+          simdjson_recurse(v, child_value);
        }
-        // end of: we are in an object under the key "user"
-      } else if (value.is<simdjson::dom::array>() || value.is<simdjson::dom::object>()) {
-          simdjson_recurse(v, 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);
+  }
+}

-__attribute__((noinline)) std::vector<int64_t>
+simdjson_really_inline std::vector<int64_t>
 simdjson_just_dom(simdjson::dom::element doc) {
  std::vector<int64_t> answer;
  simdjson_recurse(answer, doc);
@@ -107,17 +116,20 @@ simdjson_just_dom(simdjson::dom::element doc) {
  return answer;
 }

-__attribute__((noinline)) std::vector<int64_t>
+simdjson_really_inline std::vector<int64_t>
 simdjson_compute_stats(const simdjson::padded_string &p) {
  std::vector<int64_t> answer;
  simdjson::dom::parser parser;
-  simdjson::dom::element doc = parser.parse(p);
-  simdjson_recurse(answer, doc);
-  remove_duplicates(answer);
+  simdjson::dom::element doc;
+  auto error = parser.parse(p).get(doc);
+  if (!error) {
+    simdjson_recurse(answer, doc);
+    remove_duplicates(answer);
+  }
  return answer;
 }

-__attribute__((noinline)) simdjson::error_code
+simdjson_really_inline simdjson::error_code
 simdjson_just_parse(const simdjson::padded_string &p) {
  simdjson::dom::parser parser;
  return parser.parse(p).error();
@@ -175,7 +187,7 @@ void sajson_traverse(std::vector<int64_t> &answer, const sajson::value &node) {
  }
 }

-__attribute__((noinline)) std::vector<int64_t>
+simdjson_really_inline std::vector<int64_t>
 sasjon_just_dom(sajson::document &d) {
  std::vector<int64_t> answer;
  sajson_traverse(answer, d.get_root());
@@ -183,7 +195,7 @@ sasjon_just_dom(sajson::document &d) {
  return answer;
 }

-__attribute__((noinline)) std::vector<int64_t>
+simdjson_really_inline std::vector<int64_t>
 sasjon_compute_stats(const simdjson::padded_string &p) {
  std::vector<int64_t> answer;
  char *buffer = (char *)malloc(p.size());
@@ -200,7 +212,7 @@ sasjon_compute_stats(const simdjson::padded_string &p) {
  return answer;
 }

-__attribute__((noinline)) bool
+simdjson_really_inline bool
 sasjon_just_parse(const simdjson::padded_string &p) {
  char *buffer = (char *)malloc(p.size());
  memcpy(buffer, p.data(), p.size());
@@ -251,7 +263,7 @@ void rapid_traverse(std::vector<int64_t> &answer, const rapidjson::Value &v) {
  }
 }

-__attribute__((noinline)) std::vector<int64_t>
+simdjson_really_inline std::vector<int64_t>
 rapid_just_dom(rapidjson::Document &d) {
  std::vector<int64_t> answer;
  rapid_traverse(answer, d);
@@ -259,7 +271,7 @@ rapid_just_dom(rapidjson::Document &d) {
  return answer;
 }

-__attribute__((noinline)) std::vector<int64_t>
+simdjson_really_inline std::vector<int64_t>
 rapid_compute_stats(const simdjson::padded_string &p) {
  std::vector<int64_t> answer;
  char *buffer = (char *)malloc(p.size() + 1);
@@ -277,7 +289,7 @@ rapid_compute_stats(const simdjson::padded_string &p) {
  return answer;
 }

-__attribute__((noinline)) bool
+simdjson_really_inline bool
 rapid_just_parse(const simdjson::padded_string &p) {
  char *buffer = (char *)malloc(p.size() + 1);
  memcpy(buffer, p.data(), p.size());
@@ -319,18 +331,19 @@ int main(int argc, char *argv[]) {
    std::cerr << "warning: ignoring everything after " << argv[optind + 1]
              << std::endl;
  }
-  auto [p, error] = simdjson::padded_string::load(filename);
+  simdjson::padded_string p;
+  auto error = simdjson::padded_string::load(filename).get(p);
  if (error) {
    std::cerr << "Could not load the file " << filename << std::endl;
    return EXIT_FAILURE;
  }
-
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
  if (verbose) {
    std::cout << "Input has ";
-    if (p.size() > 1024 * 1024)
-      std::cout << p.size() / (1024 * 1024) << " MB ";
-    else if (p.size() > 1024)
-      std::cout << p.size() / 1024 << " KB ";
+    if (p.size() > 1000 * 1000)
+      std::cout << p.size() / (1000 * 1000) << " MB ";
+    else if (p.size() > 1000)
+      std::cout << p.size() / 1000 << " KB ";
    else
      std::cout << p.size() << " B ";
    std::cout << std::endl;
@@ -355,7 +368,7 @@ int main(int argc, char *argv[]) {
  size_t size = s1.size();

  int repeat = 500;
-  int volume = p.size();
+  size_t volume = p.size();
  if (just_data) {
    printf(
        "name cycles_per_byte cycles_per_byte_err  gb_per_s gb_per_s_err \n");
@@ -373,7 +386,8 @@ int main(int argc, char *argv[]) {
  BEST_TIME("sasjon (just parse) ", sasjon_just_parse(p), false, , repeat,
            volume, !just_data);
  simdjson::dom::parser parser;
-  simdjson::dom::element doc = parser.parse(p);
+  simdjson::dom::element doc;
+  error = parser.parse(p).get(doc);
  BEST_TIME("simdjson (just dom)  ", simdjson_just_dom(doc).size(), size,
            , repeat, volume, !just_data);
  char *buffer = (char *)malloc(p.size() + 1);
@@ -5,8 +5,8 @@
 #include <cctype>
 #ifndef _MSC_VER
 #include <dirent.h>
-#include <unistd.h>
 #endif
+#include <unistd.h>
 #include <cinttypes>

 #include <cstdio>
@@ -56,11 +56,11 @@ struct event_count {

  double elapsed_sec() const { return duration<double>(elapsed).count(); }
  double elapsed_ns() const { return duration<double, std::nano>(elapsed).count(); }
-  double cycles() const { return event_counts[CPU_CYCLES]; }
-  double instructions() const { return event_counts[INSTRUCTIONS]; }
-  double branch_misses() const { return event_counts[BRANCH_MISSES]; }
-  double cache_references() const { return event_counts[CACHE_REFERENCES]; }
-  double cache_misses() const { return event_counts[CACHE_MISSES]; }
+  double cycles() const { return static_cast<double>(event_counts[CPU_CYCLES]); }
+  double instructions() const { return static_cast<double>(event_counts[INSTRUCTIONS]); }
+  double branch_misses() const { return static_cast<double>(event_counts[BRANCH_MISSES]); }
+  double cache_references() const { return static_cast<double>(event_counts[CACHE_REFERENCES]); }
+  double cache_misses() const { return static_cast<double>(event_counts[CACHE_MISSES]); }

  event_count& operator=(const event_count& other) {
    this->elapsed = other.elapsed;
@@ -84,9 +84,9 @@ struct event_count {

 struct event_aggregate {
  int iterations = 0;
-  event_count total;
-  event_count best;
-  event_count worst;
+  event_count total{};
+  event_count best{};
+  event_count worst{};

  event_aggregate() {}

@@ -111,35 +111,35 @@ struct event_aggregate {
 };

 struct event_collector {
-  event_count count;
-  time_point<steady_clock> start_clock;
+  event_count count{};
+  time_point<steady_clock> start_clock{};

 #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;
  }
 #endif

-  really_inline void start() {
+  simdjson_really_inline void start() {
 #if defined(__linux)
    linux_events.start();
 #endif
    start_clock = steady_clock::now();
  }
-  really_inline event_count& end() {
+  simdjson_really_inline event_count& end() {
    time_point<steady_clock> end_clock = steady_clock::now();
 #if defined(__linux)
    linux_events.end(count.event_counts);
@@ -149,4 +149,4 @@ struct event_collector {
  }
 };

-#endif
+#endif
@@ -4,7 +4,8 @@
 #include <cstring>
 #include <iostream>

-never_inline
+// Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+simdjson_never_inline
 double bench(std::string filename, simdjson::padded_string& p) {
  std::chrono::time_point<std::chrono::steady_clock> start_clock =
      std::chrono::steady_clock::now();
@@ -12,7 +13,7 @@ double bench(std::string filename, simdjson::padded_string& p) {
  std::chrono::time_point<std::chrono::steady_clock> end_clock =
      std::chrono::steady_clock::now();
  std::chrono::duration<double> elapsed = end_clock - start_clock;
-  return (p.size() / (1024. * 1024 * 1024.)) / elapsed.count();
+  return (static_cast<double>(p.size()) / (1000000000.)) / elapsed.count();
 }

 int main(int argc, char *argv[]) {
@@ -32,8 +33,8 @@ int main(int argc, char *argv[]) {
  double meanval = 0;
  double maxval = 0;
  double minval = 10000;
-std::cout << "file size: "<<  (p.size() / (1024. * 1024 * 1024.)) << " GB" <<std::endl;
-  size_t times = p.size() > 1024*1024*1024 ? 5 : 50;
+std::cout << "file size: "<<  (static_cast<double>(p.size()) / (1000000000.)) << " GB" <<std::endl;
+  size_t times = p.size() > 1000000000 ? 5 : 50;
 #if __cpp_exceptions
  try {
 #endif
@@ -49,7 +50,7 @@ std::cout << "file size: "<<  (p.size() / (1024. * 1024 * 1024.)) << " GB" <<std
    return EXIT_FAILURE;
   }
 #endif
-   std::cout << "average speed: " << meanval / times << " GB/s"<< std::endl;
+   std::cout << "average speed: " << meanval / static_cast<double>(times) << " GB/s"<< std::endl;
   std::cout << "min speed    : " << minval << " GB/s" << std::endl;
   std::cout << "max speed    : " << maxval << " GB/s" << std::endl;
   return EXIT_SUCCESS;
@@ -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>
@@ -17,14 +25,15 @@
 template <int TYPE = PERF_TYPE_HARDWARE> class LinuxEvents {
  int fd;
  bool working;
-  perf_event_attr attribs;
-  int num_events;
-  std::vector<uint64_t> temp_result_vec;
-  std::vector<uint64_t> ids;
+  perf_event_attr attribs{};
+  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;
@@ -43,7 +52,7 @@ public:
    uint32_t i = 0;
    for (auto config : config_vec) {
      attribs.config = config;
-      fd = syscall(__NR_perf_event_open, &attribs, pid, cpu, group, flags);
+      fd = static_cast<int>(syscall(__NR_perf_event_open, &attribs, pid, cpu, group, flags));
      if (fd == -1) {
        report_error("perf_event_open");
      }
@@ -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;
  }
 };
@@ -45,6 +45,16 @@ std::string rapid_stringme(char *json) {
  return buffer.GetString();
 }

+std::string simdjson_stringme(simdjson::padded_string & json) {
+  std::stringstream ss;
+  dom::parser parser;
+  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();
+}
+

 int main(int argc, char *argv[]) {
  int c;
@@ -67,27 +77,33 @@ int main(int argc, char *argv[]) {
    exit(1);
  }
  const char *filename = argv[optind];
-  auto [p, error] = simdjson::padded_string::load(filename);
+  simdjson::padded_string p;
+  auto error = simdjson::padded_string::load(filename).get(p);
  if (error) {
    std::cerr << "Could not load the file " << filename << std::endl;
    return EXIT_FAILURE;
  }
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
  if (verbose) {
    std::cout << "Input has ";
-    if (p.size() > 1024 * 1024)
-      std::cout << p.size() / (1024 * 1024) << " MB ";
-    else if (p.size() > 1024)
-      std::cout << p.size() / 1024 << " KB ";
+    if (p.size() > 1000 * 1000)
+      std::cout << p.size() / (1000 * 1000) << " MB ";
+    else if (p.size() > 1000)
+      std::cout << p.size() / 1000 << " KB ";
    else
      std::cout << p.size() << " B ";
    std::cout << std::endl;
  }
  char *buffer = simdjson::internal::allocate_padded_buffer(p.size() + 1);
+  if(buffer == nullptr) {
+    std::cerr << "Out of memory!" << std::endl;
+    abort();
+  }
  memcpy(buffer, p.data(), p.size());
  buffer[p.size()] = '\0';

  int repeat = 50;
-  int volume = p.size();
+  size_t volume = p.size();
  if (just_data) {
    printf(
        "name cycles_per_byte cycles_per_byte_err  gb_per_s gb_per_s_err \n");
@@ -102,18 +118,25 @@ int main(int argc, char *argv[]) {
  BEST_TIME_NOCHECK(
      "despacing with RapidJSON Insitu", rapid_stringme_insitu((char *)buffer),
      memcpy(buffer, p.data(), p.size()), repeat, volume, !just_data);
+
+  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) ? 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 "
         "of original) \n",
-         outlength, p.size(), outlength * 100.0 / p.size());
+         outlength, p.size(), static_cast<double>(outlength) * 100.0 / static_cast<double>(p.size()));

  /***
   * Is it worth it to minify before parsing?
@@ -124,9 +147,12 @@ int main(int argc, char *argv[]) {
            !just_data);

  char *mini_buffer = simdjson::internal::allocate_padded_buffer(p.size() + 1);
+  if(mini_buffer == nullptr) {
+    std::cerr << "Out of memory" << std::endl;
+    abort();
+  }
  size_t minisize;
-  auto minierror = simdjson::active_implementation->minify((const uint8_t *)p.data(), p.size(),
-                                                           (uint8_t *)mini_buffer, minisize);
+  auto minierror = minify(p.data(), p.size(),mini_buffer, minisize);
  if (!minierror) { std::cerr << minierror << std::endl; exit(1); }
  mini_buffer[minisize] = '\0';

@@ -4,8 +4,8 @@
 #include <cctype>
 #ifndef _MSC_VER
 #include <dirent.h>
-#include <unistd.h>
 #endif
+#include <unistd.h>
 #include <cinttypes>

 #include <cstdio>
@@ -62,11 +62,14 @@ void print_usage(ostream& out) {
  out << "-v           - Verbose output." << endl;
  out << "-s stage1    - Stop after find_structural_bits." << endl;
  out << "-s all       - Run all stages." << endl;
-  out << "-H           - Make the buffers hot (reduce page allocation during parsing)" << endl;
+  out << "-C           - Leave the buffers cold (includes page allocation and related OS tasks during parsing, speed tied to OS performance)" << endl;
+  out << "-H           - Make the buffers hot (reduce page allocation and related OS tasks during parsing) [default]" << endl;
  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;
+    }
  }
 }

@@ -78,69 +81,83 @@ void exit_usage(string message) {
 }

 struct option_struct {
-  vector<char*> files;
+  vector<char*> files{};
  bool stage1_only = false;

  int32_t iterations = 200;
-  int32_t iteration_step = 50;
+  int32_t iteration_step = -1;

  bool verbose = false;
  bool tabbed_output = false;
-  bool hotbuffers = false;
+  /**
+   * Benchmarking on a cold parser instance means that the parsing may include
+   * memory allocation at the OS level. This may lead to apparently odd results
+   * such that higher speed under the Windows Subsystem for Linux than under the
+   * regular Windows, for the same machine. It is arguably misleading to benchmark
+   * how the OS allocates memory, when we really want to just benchmark simdjson.
+   */
+  bool hotbuffers = true;

  option_struct(int argc, char **argv) {
-    #ifndef _MSC_VER
-      int c;
+    int c;

-      while ((c = getopt(argc, argv, "vtn:i:a:s:H")) != -1) {
-        switch (c) {
-        case 'n':
-          iterations = atoi(optarg);
-          break;
-        case 'i':
-          iteration_step = atoi(optarg);
-          break;
-        case 't':
-          tabbed_output = true;
-          break;
-        case 'v':
-          verbose = true;
-          break;
-        case 'a': {
-          const implementation *impl = simdjson::available_implementations[optarg];
-          if (!impl) {
-            std::string exit_message = string("Unsupported option value -a ") + optarg + ": expected -a  with one of ";
-            for (auto imple : simdjson::available_implementations) {
+    while ((c = getopt(argc, argv, "vtn:i:a:s:HC")) != -1) {
+      switch (c) {
+      case 'n':
+        iterations = atoi(optarg);
+        break;
+      case 'i':
+        iteration_step = atoi(optarg);
+        break;
+      case 't':
+        tabbed_output = true;
+        break;
+      case 'v':
+        verbose = true;
+        break;
+      case 'a': {
+        const implementation *impl = simdjson::available_implementations[optarg];
+        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) {
+            if(imple->supported_by_runtime_system()) {
              exit_message += imple->name();
              exit_message += " ";
            }
-            exit_usage(exit_message);
          }
-          simdjson::active_implementation = impl;
-          break;
-        }
-        case 'H':
-          hotbuffers = true;
-          break;
-        case 's':
-          if (!strcmp(optarg, "stage1")) {
-            stage1_only = true;
-          } else if (!strcmp(optarg, "all")) {
-            stage1_only = false;
-          } else {
-            exit_usage(string("Unsupported option value -s ") + optarg + ": expected -s stage1 or all");
-          }
-          break;
-        default:
-          // reaching here means an argument was given to getopt() which did not have a case label
-          exit_usage("Unexpected argument - missing case for option "+
-                     std::string(1,static_cast<char>(c))+
-                     " (programming error)");
+          exit_usage(exit_message);
        }
+        simdjson::active_implementation = impl;
+        break;
      }
-    #else
-      int optind = 1;
-    #endif
+      case 'C':
+        hotbuffers = false;
+        break;
+      case 'H':
+        hotbuffers = true;
+        break;
+      case 's':
+        if (!strcmp(optarg, "stage1")) {
+          stage1_only = true;
+        } else if (!strcmp(optarg, "all")) {
+          stage1_only = false;
+        } else {
+          exit_usage(string("Unsupported option value -s ") + optarg + ": expected -s stage1 or all");
+        }
+        break;
+      default:
+        // reaching here means an argument was given to getopt() which did not have a case label
+        exit_usage("Unexpected argument - missing case for option "+
+                    std::string(1,static_cast<char>(c))+
+                    " (programming error)");
+      }
+    }
+
+    if (iteration_step == -1) {
+      iteration_step = iterations / 50;
+      if (iteration_step < 200) { iteration_step = 200; }
+      if (iteration_step > iterations) { iteration_step = iterations; }
+    }

    // All remaining arguments are considered to be files
    for (int i=optind; i<argc; i++) {
@@ -149,17 +166,6 @@ struct option_struct {
    if (files.empty()) {
      exit_usage("No files specified");
    }
-
-    // Keeps the numbers the same for CI (old ./parse didn't have a two-stage loop)
-    if (files.size() == 1) {
-      iteration_step = iterations;
-    }
-
-    #if !defined(__linux__)
-      if (tabbed_output) {
-        exit_error("tabbed_output (-t) flag only works under linux.\n");
-      }
-    #endif
  }
 };

@@ -212,7 +218,7 @@ int main(int argc, char *argv[]) {
  if (!options.verbose) { progress.erase(); }

  for (size_t i=0; i<options.files.size(); i++) {
-    benchmarkers[i]->print(options.tabbed_output, options.iterations);
+    benchmarkers[i]->print(options.tabbed_output);
    delete benchmarkers[i];
  }

@@ -1,149 +1,191 @@
-#include <iostream>
 #include <algorithm>
 #include <chrono>
-#include <vector>
+#include <iostream>
 #include <map>
+#include <vector>

 #include "simdjson.h"

-#define NB_ITERATION 5
-#define MIN_BATCH_SIZE 200000
+#define NB_ITERATION 20
+#define MIN_BATCH_SIZE 10000
 #define MAX_BATCH_SIZE 10000000

 bool test_baseline = false;
 bool test_per_batch = true;
-bool test_best_batch = true;
+bool test_best_batch = false;

-bool compare(std::pair<size_t, double> i, std::pair<size_t, double> j){
-    return i.second > j.second;
+bool compare(std::pair<size_t, double> i, std::pair<size_t, double> j) {
+  return i.second > j.second;
 }

-int main (int argc, char *argv[]){
+int main(int argc, char *argv[]) {

-    if (argc <= 1) {
-        std::cerr << "Usage: " << argv[0] << " <jsonfile>" << std::endl;
-        exit(1);
-    }
-    const char *filename = argv[1];
-    auto [p, err] = simdjson::padded_string::load(filename);
-    if (err) {
-        std::cerr << "Could not load the file " << filename << std::endl;
+  if (argc <= 1) {
+    std::cerr << "Usage: " << argv[0] << " <jsonfile>" << std::endl;
+    exit(1);
+  }
+  const char *filename = argv[1];
+  auto[p, err] = simdjson::padded_string::load(filename);
+  if (err) {
+    std::cerr << "Could not load the file " << filename << std::endl;
+    return EXIT_FAILURE;
+  }
+  if (test_baseline) {
+    std::wclog << "Baseline: Getline + normal parse... " << std::endl;
+    std::cout << "Gigabytes/second\t"
+              << "Nb of documents parsed" << std::endl;
+    for (auto i = 0; i < 3; i++) {
+      // Actual test
+      simdjson::dom::parser parser;
+      simdjson::error_code alloc_error = parser.allocate(p.size());
+      if (alloc_error) {
+        std::cerr << alloc_error << std::endl;
        return EXIT_FAILURE;
+      }
+      std::istringstream ss(std::string(p.data(), p.size()));
+
+      auto start = std::chrono::steady_clock::now();
+      int count = 0;
+      std::string line;
+      int parse_res = simdjson::SUCCESS;
+      while (getline(ss, line)) {
+        // TODO we're likely triggering simdjson's padding reallocation here. Is
+        // that intentional?
+        parser.parse(line);
+        count++;
+      }
+
+      auto end = std::chrono::steady_clock::now();
+
+      std::chrono::duration<double> secs = end - start;
+      double speedinGBs = static_cast<double>(p.size()) /
+                          (static_cast<double>(secs.count()) * 1000000000.0);
+      std::cout << speedinGBs << "\t\t\t\t" << count << std::endl;
+
+      if (parse_res != simdjson::SUCCESS) {
+        std::cerr << "Parsing failed" << std::endl;
+        exit(1);
+      }
    }
-    if (test_baseline) {
-        std::wclog << "Baseline: Getline + normal parse... " << std::endl;
-        std::cout << "Gigabytes/second\t" << "Nb of documents parsed" << std::endl;
-        for (auto i = 0; i < 3; i++) {
-            //Actual test
-            simdjson::dom::parser parser;
-            simdjson::error_code alloc_error = parser.allocate(p.size());
-            if (alloc_error) {
-                std::cerr << alloc_error << std::endl;
-                return EXIT_FAILURE;
-            }
-            std::istringstream ss(std::string(p.data(), p.size()));
+  }

-            auto start = std::chrono::steady_clock::now();
-            int count = 0;
-            std::string line;
-            int parse_res = simdjson::SUCCESS;
-            while (getline(ss, line)) {
-                // TODO we're likely triggering simdjson's padding reallocation here. Is that intentional?
-                parser.parse(line);
-                count++;
-            }
+  std::map<size_t, double> batch_size_res;
+  if (test_per_batch) {
+    std::wclog << "parse_many: Speed per batch_size... from " << MIN_BATCH_SIZE
+               << " bytes to " << MAX_BATCH_SIZE << " bytes..." << std::endl;
+    std::cout << "Batch Size\t"
+              << "Gigabytes/second\t"
+              << "Nb of documents parsed" << std::endl;
+    for (size_t i = MIN_BATCH_SIZE; i <= MAX_BATCH_SIZE;
+         i += (MAX_BATCH_SIZE - MIN_BATCH_SIZE) / 100) {
+      batch_size_res.insert(std::pair<size_t, double>(i, 0));
+      int count;
+      for (size_t j = 0; j < 5; j++) {
+        // Actual test
+        simdjson::dom::parser parser;
+        simdjson::error_code error;

-            auto end = std::chrono::steady_clock::now();
-
-            std::chrono::duration<double> secs = end - start;
-            double speedinGBs = (p.size()) / (secs.count() * 1000000000.0);
-            std::cout << speedinGBs << "\t\t\t\t" << count << std::endl;
-
-            if (parse_res != simdjson::SUCCESS) {
-                std::cerr << "Parsing failed" << std::endl;
-                exit(1);
-            }
+        auto start = std::chrono::steady_clock::now();
+        count = 0;
+        simdjson::dom::document_stream docs;
+        if ((error = parser.parse_many(p, i).get(docs))) {
+          std::wcerr << "Parsing failed with: " << error << std::endl;
+          exit(1);
        }
+        for (auto result : docs) {
+          error = result.error();
+          if (error) {
+            std::wcerr << "Parsing failed with: " << error << std::endl;
+            exit(1);
+          }
+          count++;
+        }
+        auto end = std::chrono::steady_clock::now();
+
+        std::chrono::duration<double> secs = end - start;
+        double speedinGBs = static_cast<double>(p.size()) /
+                            (static_cast<double>(secs.count()) * 1000000000.0);
+        if (speedinGBs > batch_size_res.at(i))
+          batch_size_res[i] = speedinGBs;
+      }
+      std::cout << i << "\t\t" << std::fixed << std::setprecision(3)
+                << batch_size_res.at(i) << "\t\t\t\t" << count << std::endl;
+    }
+  }
+  size_t optimal_batch_size{};
+  double best_speed{};
+  if (test_per_batch) {
+    std::pair<size_t, double> best_results;
+    best_results =
+        (*min_element(batch_size_res.begin(), batch_size_res.end(), compare));
+    optimal_batch_size = best_results.first;
+    best_speed = best_results.second;
+  } else {
+    optimal_batch_size = MIN_BATCH_SIZE;
+  }
+  std::wclog << "Seemingly optimal batch_size: " << optimal_batch_size << "..."
+             << std::endl;
+  std::wclog << "Best speed: " << best_speed << "..." << std::endl;
+
+  if (test_best_batch) {
+    std::wclog << "Starting speed test... Best of " << NB_ITERATION
+               << " iterations..." << std::endl;
+    std::vector<double> res;
+    for (int i = 0; i < NB_ITERATION; i++) {
+
+      // Actual test
+      simdjson::dom::parser parser;
+      simdjson::error_code error;
+
+      auto start = std::chrono::steady_clock::now();
+      // This includes allocation of the parser
+      simdjson::dom::document_stream docs;
+      if ((error = parser.parse_many(p, optimal_batch_size).get(docs))) {
+        std::wcerr << "Parsing failed with: " << error << std::endl;
+        exit(1);
+      }
+      for (auto result : docs) {
+        error = result.error();
+        if (error) {
+          std::wcerr << "Parsing failed with: " << error << std::endl;
+          exit(1);
+        }
+      }
+      auto end = std::chrono::steady_clock::now();
+
+      std::chrono::duration<double> secs = end - start;
+      res.push_back(secs.count());
    }

-    std::map<size_t, double> batch_size_res;
-    if(test_per_batch) {
-        std::wclog << "parse_many: Speed per batch_size... from " << MIN_BATCH_SIZE
-                << " bytes to " << MAX_BATCH_SIZE << " bytes..." << std::endl;
-        std::cout << "Batch Size\t" << "Gigabytes/second\t" << "Nb of documents parsed" << std::endl;
-        for (size_t i = MIN_BATCH_SIZE; i <= MAX_BATCH_SIZE; i += (MAX_BATCH_SIZE - MIN_BATCH_SIZE) / 50) {
-            batch_size_res.insert(std::pair<size_t, double>(i, 0));
-            int count;
-            for (size_t j = 0; j < 5; j++) {
-                //Actual test
-                simdjson::dom::parser parser;
-                simdjson::error_code error;
+    double min_result = *min_element(res.begin(), res.end());
+    double speedinGBs =
+        static_cast<double>(p.size()) / (min_result * 1000000000.0);

-                auto start = std::chrono::steady_clock::now();
-                count = 0;
-                for (auto result : parser.parse_many(p, 4000000)) {
-                    error = result.error();
-                    count++;
-                }
-                auto end = std::chrono::steady_clock::now();
+    std::cout << "Min:  " << min_result << " bytes read: " << p.size()
+              << " Gigabytes/second: " << speedinGBs << std::endl;
+  }
+#ifdef SIMDJSON_THREADS_ENABLED
+  // Multithreading probably does not help matters for small files (less than 10
+  // MB).
+  if (p.size() < 10000000) {
+    std::cout << std::endl;

-                std::chrono::duration<double> secs = end - start;
-                double speedinGBs = (p.size()) / (secs.count() * 1000000000.0);
-                if (speedinGBs > batch_size_res.at(i))
-                    batch_size_res[i] = speedinGBs;
+    std::cout << "Warning: your file is small and the performance results are "
+                 "probably meaningless"
+              << std::endl;
+    std::cout << "as far as multithreaded performance goes." << std::endl;

-                if (error != simdjson::SUCCESS) {
-                    std::wcerr << "Parsing failed with: " << error << std::endl;
-                    exit(1);
-                }
-            }
-            std::cout << i << "\t\t" << std::fixed << std::setprecision(3) << batch_size_res.at(i) << "\t\t\t\t" << count << std::endl;
+    std::cout << std::endl;

-        }
-    }
+    std::cout
+        << "Try to concatenate the file with itself to generate a large one."
+        << std::endl;
+    std::cout << "In bash: " << std::endl;
+    std::cout << "for i in {1..1000}; do cat '" << filename
+              << "' >> bar.ndjson; done" << std::endl;
+    std::cout << argv[0] << " bar.ndjson" << std::endl;
+  }
+#endif

-    if (test_best_batch) {
-        size_t optimal_batch_size;
-        if (test_per_batch) {
-            optimal_batch_size = (*min_element(batch_size_res.begin(), batch_size_res.end(), compare)).first;
-        } else {
-            optimal_batch_size = MIN_BATCH_SIZE;
-        }
-        std::wclog << "Starting speed test... Best of " << NB_ITERATION << " iterations..." << std::endl;
-        std::wclog << "Seemingly optimal batch_size: " << optimal_batch_size << "..." << std::endl;
-        std::vector<double> res;
-        for (int i = 0; i < NB_ITERATION; i++) {
-
-            // Actual test
-            simdjson::dom::parser parser;
-            simdjson::error_code error;
-
-            auto start = std::chrono::steady_clock::now();
-            // TODO this includes allocation of the parser; is that intentional?
-            for (auto result : parser.parse_many(p, 4000000)) {
-                error = result.error();
-            }
-            auto end = std::chrono::steady_clock::now();
-
-            std::chrono::duration<double> secs = end - start;
-            res.push_back(secs.count());
-
-            if (error != simdjson::SUCCESS) {
-                std::wcerr << "Parsing failed with: " << error << std::endl;
-                exit(1);
-            }
-
-        }
-
-        std::min(res.begin(), res.end());
-
-        double min_result = *min_element(res.begin(), res.end());
-        double speedinGBs = (p.size()) / (min_result * 1000000000.0);
-
-
-        std::cout << "Min:  " << min_result << " bytes read: " << p.size()
-                << " Gigabytes/second: " << speedinGBs << std::endl;
-    }
-
-    return 0;
+  return 0;
 }
@@ -48,13 +48,14 @@ void print_stat(const stat_t &s) {
         s.true_count, s.false_count);
 }

-
-really_inline void simdjson_process_atom(stat_t &s,
+simdjson_really_inline void simdjson_process_atom(stat_t &s,
                                         simdjson::dom::element element) {
  if (element.is<double>()) {
    s.number_count++;
  } else if (element.is<bool>()) {
-    if (element.get<bool>()) {
+    simdjson::error_code error;
+    bool v;
+    if (not (error = element.get(v)) && v) {
      s.true_count++;
    } else {
      s.false_count++;
@@ -65,11 +66,17 @@ really_inline void simdjson_process_atom(stat_t &s,
 }

 void simdjson_recurse(stat_t &s, simdjson::dom::element element) {
+  error_code error;
  if (element.is<simdjson::dom::array>()) {
    s.array_count++;
-    auto [array, array_error] = element.get<simdjson::dom::array>();
+    dom::array array;
+    if ((error = element.get(array))) {
+      std::cerr << error << std::endl;
+      abort();
+    }
    for (auto child : array) {
-      if (child.is<simdjson::dom::array>() || child.is<simdjson::dom::object>()) {
+      if (child.is<simdjson::dom::array>() ||
+          child.is<simdjson::dom::object>()) {
        simdjson_recurse(s, child);
      } else {
        simdjson_process_atom(s, child);
@@ -77,12 +84,17 @@ void simdjson_recurse(stat_t &s, simdjson::dom::element element) {
    }
  } else if (element.is<simdjson::dom::object>()) {
    s.object_count++;
-    auto [object, object_error] = element.get<simdjson::dom::object>();
-    for (auto [key, value] : object) {
-      if (value.is<simdjson::dom::array>() || value.is<simdjson::dom::object>()) {
-        simdjson_recurse(s, value);
+    dom::object object;
+    if ((error = element.get(object))) {
+      std::cerr << error << std::endl;
+      abort();
+    }
+    for (auto field : object) {
+      if (field.value.is<simdjson::dom::array>() ||
+          field.value.is<simdjson::dom::object>()) {
+        simdjson_recurse(s, field.value);
      } else {
-        simdjson_process_atom(s, value);
+        simdjson_process_atom(s, field.value);
      }
    }
  } else {
@@ -90,11 +102,11 @@ void simdjson_recurse(stat_t &s, simdjson::dom::element element) {
  }
 }

-__attribute__((noinline)) stat_t
-simdjson_compute_stats(const simdjson::padded_string &p) {
+simdjson_never_inline stat_t simdjson_compute_stats(const simdjson::padded_string &p) {
  stat_t s{};
  simdjson::dom::parser parser;
-  auto [doc, error] = parser.parse(p);
+  simdjson::dom::element doc;
+  auto error = parser.parse(p).get(doc);
  if (error) {
    s.valid = false;
    return s;
@@ -104,6 +116,130 @@ simdjson_compute_stats(const simdjson::padded_string &p) {
  return s;
 }

+///
+struct Stat {
+  size_t objectCount;
+  size_t arrayCount;
+  size_t numberCount;
+  size_t stringCount;
+  size_t trueCount;
+  size_t falseCount;
+  size_t nullCount;
+
+  size_t memberCount;  // Number of members in all objects
+  size_t elementCount; // Number of elements in all arrays
+  size_t stringLength; // Number of code units in all strings
+};
+
+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: {
+    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: {
+    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;
+  case dom::element_type::INT64:
+  case dom::element_type::UINT64:
+  case dom::element_type::DOUBLE:
+    stat.numberCount++;
+    break;
+  case dom::element_type::STRING: {
+    stat.stringCount++;
+    std::string_view sv;
+    SIMDJSON_TRY( v.get(sv) );
+    stat.stringLength += sv.size();
+  } break;
+  case dom::element_type::BOOL: {
+    bool b;
+    SIMDJSON_TRY( v.get(b) );
+    if (b) {
+      stat.trueCount++;
+    } else {
+      stat.falseCount++;
+    }
+  } break;
+  case dom::element_type::NULL_VALUE:
+    ++stat.nullCount;
+    break;
+  }
+  return SUCCESS;
+}
+
+static void RapidGenStat(Stat &stat, const rapidjson::Value &v) {
+  switch (v.GetType()) {
+  case kNullType:
+    stat.nullCount++;
+    break;
+  case kFalseType:
+    stat.falseCount++;
+    break;
+  case kTrueType:
+    stat.trueCount++;
+    break;
+
+  case kObjectType:
+    for (Value::ConstMemberIterator m = v.MemberBegin(); m != v.MemberEnd();
+         ++m) {
+      stat.stringLength += m->name.GetStringLength();
+      RapidGenStat(stat, m->value);
+    }
+    stat.objectCount++;
+    stat.memberCount += (v.MemberEnd() - v.MemberBegin());
+    stat.stringCount += (v.MemberEnd() - v.MemberBegin()); // Key
+    break;
+
+  case kArrayType:
+    for (Value::ConstValueIterator i = v.Begin(); i != v.End(); ++i)
+      RapidGenStat(stat, *i);
+    stat.arrayCount++;
+    stat.elementCount += v.Size();
+    break;
+
+  case kStringType:
+    stat.stringCount++;
+    stat.stringLength += v.GetStringLength();
+    break;
+
+  case kNumberType:
+    stat.numberCount++;
+    break;
+  }
+}
+simdjson_never_inline Stat rapidjson_compute_stats_ref(const rapidjson::Value &doc) {
+  Stat s{};
+  RapidGenStat(s, doc);
+  return s;
+}
+
+simdjson_never_inline Stat
+simdjson_compute_stats_refplus(const simdjson::dom::element &doc) {
+  Stat s{};
+  auto error = GenStatPlus(s, doc);
+  if (error) { std::cerr << error << std::endl; abort(); }
+  return s;
+}
+
 // see
 // https://github.com/miloyip/nativejson-benchmark/blob/master/src/tests/sajsontest.cpp
 void sajson_traverse(stat_t &stats, const sajson::value &node) {
@@ -147,9 +283,8 @@ void sajson_traverse(stat_t &stats, const sajson::value &node) {
  }
 }

-__attribute__((noinline)) stat_t
-sasjon_compute_stats(const simdjson::padded_string &p) {
-  stat_t answer;
+simdjson_never_inline stat_t sasjon_compute_stats(const simdjson::padded_string &p) {
+  stat_t answer{};
  char *buffer = (char *)malloc(p.size());
  if (buffer == nullptr) {
    return answer;
@@ -209,9 +344,8 @@ void rapid_traverse(stat_t &stats, const rapidjson::Value &v) {
  }
 }

-__attribute__((noinline)) stat_t
-rapid_compute_stats(const simdjson::padded_string &p) {
-  stat_t answer;
+simdjson_never_inline stat_t rapid_compute_stats(const simdjson::padded_string &p) {
+  stat_t answer{};
  char *buffer = (char *)malloc(p.size() + 1);
  if (buffer == nullptr) {
    return answer;
@@ -236,9 +370,9 @@ rapid_compute_stats(const simdjson::padded_string &p) {
  return answer;
 }

-__attribute__((noinline)) stat_t
+simdjson_never_inline stat_t
 rapid_accurate_compute_stats(const simdjson::padded_string &p) {
-  stat_t answer;
+  stat_t answer{};
  char *buffer = (char *)malloc(p.size() + 1);
  if (buffer == nullptr) {
    return answer;
@@ -292,18 +426,19 @@ int main(int argc, char *argv[]) {
    std::cerr << "warning: ignoring everything after " << argv[optind + 1]
              << std::endl;
  }
-  auto [p, error] = simdjson::padded_string::load(filename);
+  simdjson::padded_string p;
+  auto error = simdjson::padded_string::load(filename).get(p);
  if (error) {
    std::cerr << "Could not load the file " << filename << std::endl;
    return EXIT_FAILURE;
  }
-
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
  if (verbose) {
    std::cout << "Input has ";
-    if (p.size() > 1024 * 1024)
-      std::cout << p.size() / (1024 * 1024) << " MB ";
-    else if (p.size() > 1024)
-      std::cout << p.size() / 1024 << " KB ";
+    if (p.size() > 1000 * 1000)
+      std::cout << p.size() / (1000 * 1000) << " MB ";
+    else if (p.size() > 1000)
+      std::cout << p.size() / 1000 << " KB ";
    else
      std::cout << p.size() << " B ";
    std::cout << std::endl;
@@ -331,7 +466,7 @@ int main(int argc, char *argv[]) {
  assert(stat_equal(s1, s2));
  assert(stat_equal(s1, s3));
  int repeat = 50;
-  int volume = p.size();
+  size_t volume = p.size();
  if (just_data) {
    printf("name cycles_per_byte cycles_per_byte_err gb_per_s gb_per_s_err \n");
  }
@@ -339,8 +474,29 @@ int main(int argc, char *argv[]) {
            repeat, volume, !just_data);
  BEST_TIME("RapidJSON           ", rapid_compute_stats(p).valid, true, ,
            repeat, volume, !just_data);
-  BEST_TIME("RapidJSON (precise) ", rapid_accurate_compute_stats(p).valid, true, ,
-            repeat, volume, !just_data);
+  BEST_TIME("RapidJSON (precise) ", rapid_accurate_compute_stats(p).valid, true,
+            , repeat, volume, !just_data);
  BEST_TIME("sasjon              ", sasjon_compute_stats(p).valid, true, ,
            repeat, volume, !just_data);
+  if (!just_data) {
+    printf("API traversal tests\n");
+    printf("Based on https://github.com/miloyip/nativejson-benchmark\n");
+    simdjson::dom::parser parser;
+    simdjson::dom::element doc;
+    auto error = parser.parse(p).get(doc);
+    if (error) { std::cerr << error << std::endl; abort(); }
+    size_t refval = simdjson_compute_stats_refplus(doc).objectCount;
+
+    BEST_TIME("simdjson            ",
+              simdjson_compute_stats_refplus(doc).objectCount, refval, , repeat,
+              volume, !just_data);
+    char *buffer = (char *)malloc(p.size() + 1);
+    memcpy(buffer, p.data(), p.size());
+    buffer[p.size()] = '\0';
+    rapidjson::Document d;
+    d.ParseInsitu<kParseValidateEncodingFlag>(buffer);
+    BEST_TIME("rapid              ", rapidjson_compute_stats_ref(d).objectCount,
+              refval, , repeat, volume, !just_data);
+    free(buffer);
+  }
 }
@@ -1,8 +1,8 @@
 #include "simdjson.h"

+#include <unistd.h>
 #ifndef _MSC_VER
 #include "linux-perf-events.h"
-#include <unistd.h>
 #ifdef __linux__
 #include <libgen.h>
 #endif //__linux__
@@ -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,6 +27,9 @@ SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;

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

 #include "fastjson.cpp"
@@ -53,7 +57,7 @@ using namespace rapidjson;

 #ifdef ALLPARSER
 // fastjson has a tricky interface
-void on_json_error(void *, 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,94 +69,139 @@ bool fastjson_parse(const char *input) {
 // end of fastjson stuff
 #endif

-never_inline size_t sum_line_lengths(char * data, size_t length) {
-  std::stringstream is;
-  is.rdbuf()->pubsetbuf(data, length);
+simdjson_never_inline size_t sum_line_lengths(std::stringstream &is) {
  std::string line;
  size_t sumofalllinelengths{0};
-  while(getline(is, line)) {
+  while (std::getline(is, line)) {
    sumofalllinelengths += line.size();
  }
  return sumofalllinelengths;
 }

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

-bool bench(const char *filename, bool verbose, bool just_data, int repeat_multiplier) {
-  auto [p, err] = simdjson::padded_string::load(filename);
-  if (err) {
-    std::cerr << "Could not load the file " << filename << std::endl;
+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;
    return false;
  }

-  int repeat = (50000000 * repeat_multiplier) / 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 ";
-    if (p.size() > 1024 * 1024)
-      std::cout << p.size() / (1024 * 1024) << " MB";
-    else if (p.size() > 1024)
-      std::cout << p.size() / 1024 << " KB";
+    if (p.size() > 1000 * 1000)
+      std::cout << p.size() / (1000 * 1000) << " MB";
+    else if (p.size() > 1000)
+      std::cout << p.size() / 1000 << " KB";
    else
      std::cout << p.size() << " B";
    std::cout << ": will run " << repeat << " iterations." << std::endl;
  }
-  int volume = p.size();
+  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) {
-    size_t lc = sum_line_lengths(p.data(), p.size());
-    BEST_TIME("getline ",sum_line_lengths(p.data(), p.size()) , lc, , 
-       repeat, volume, !just_data);
+    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);
  }

-  if (!just_data)
-    BEST_TIME("simdjson (dynamic mem) ", simdjson::dom::parser().parse(p).error(), simdjson::SUCCESS,
-              , repeat, volume, !just_data);
+  if (!just_data) {
+    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);
+  }
  // (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);
+
+  {
+    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);
+  }
+  {
+    
+    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
@@ -160,59 +209,61 @@ bool bench(const char *filename, bool verbose, bool just_data, int repeat_multip
              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(), 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,
@@ -230,12 +281,13 @@ bool bench(const char *filename, bool verbose, bool just_data, int repeat_multip
 #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);
@@ -248,68 +300,88 @@ bool bench(const char *filename, bool verbose, bool just_data, int repeat_multip
    results.resize(evts.size());
    stats.resize(evts.size());
    std::fill(stats.begin(), stats.end(), 0); // unnecessary
-    for (int i = 0; i < repeat; i++) {
+    for (decltype(repeat) i = 0; i < repeat; i++) {
      unified.start();
-      auto [doc, parse_error] = parser.parse(p);
+      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",
-           stats[0] * 1.0 / repeat, stats[1] * 1.0 / repeat,
-           stats[2] * 1.0 / repeat, stats[3] * 1.0 / repeat,
-           stats[4] * 1.0 / repeat, volume * repeat * 1.0 / stats[2],
-           stats[1] * 1.0 / stats[0], stats[1] * 1.0 / (volume * 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 (int i = 0; i < repeat; i++) {
-      memcpy(buffer, p.data(), p.size());
+    for (decltype(repeat) i = 0; i < repeat; i++) {
+      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",
-           stats[0] * 1.0 / repeat, stats[1] * 1.0 / repeat,
-           stats[2] * 1.0 / repeat, stats[3] * 1.0 / repeat,
-           stats[4] * 1.0 / repeat, volume * repeat * 1.0 / stats[2],
-           stats[1] * 1.0 / stats[0], stats[1] * 1.0 / (volume * 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 (int i = 0; i < repeat; i++) {
-      memcpy(buffer, p.data(), p.size());
+    for (decltype(repeat) i = 0; i < repeat; i++) {
+      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",
-           stats[0] * 1.0 / repeat, stats[1] * 1.0 / repeat,
-           stats[2] * 1.0 / repeat, stats[3] * 1.0 / repeat,
-           stats[4] * 1.0 / repeat, volume * repeat * 1.0 / stats[2],
-           stats[1] * 1.0 / stats[0], stats[1] * 1.0 / (volume * 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;
 }

@@ -336,13 +408,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
+
@@ -0,0 +1,514 @@
+#pragma once
+
+#include "simdjson.h"
+#include "tweet.h"
+#include <vector>
+
+namespace partial_tweets {
+
+using namespace simdjson;
+using namespace simdjson::builtin;
+using namespace simdjson::builtin::stage2;
+
+struct sax_tweet_reader_visitor {
+public:
+  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);
+  simdjson_really_inline error_code visit_key(json_iterator &iter, const uint8_t *key);
+  simdjson_really_inline error_code visit_primitive(json_iterator &iter, const uint8_t *value);
+  simdjson_really_inline error_code visit_array_start(json_iterator &iter);
+  simdjson_really_inline error_code visit_array_end(json_iterator &iter);
+  simdjson_really_inline error_code visit_object_end(json_iterator &iter);
+  simdjson_really_inline error_code visit_document_end(json_iterator &iter);
+  simdjson_really_inline error_code visit_empty_array(json_iterator &iter);
+  simdjson_really_inline error_code visit_empty_object(json_iterator &iter);
+  simdjson_really_inline error_code visit_root_primitive(json_iterator &iter, const uint8_t *value);
+  simdjson_really_inline error_code increment_count(json_iterator &iter);
+
+private:
+  // Since we only care about one thing at each level, we just use depth as the marker for what
+  // object/array we're nested inside.
+  enum class containers {
+    document = 0,   //
+    top_object = 1, // {
+    statuses = 2,   // { "statuses": [
+    tweet = 3,      // { "statuses": [ {
+    user = 4        // { "statuses": [ { "user": {
+  };
+  /**
+   * The largest depth we care about.
+   * There can be things at lower depths.
+   */
+  static constexpr uint32_t MAX_SUPPORTED_DEPTH = uint32_t(containers::user);
+  static constexpr const char *STATE_NAMES[] = {
+    "document",
+    "top object",
+    "statuses",
+    "tweet",
+    "user"
+  };
+  enum class field_type {
+    any,
+    unsigned_integer,
+    string,
+    nullable_unsigned_integer,
+    object,
+    array
+  };
+  struct field {
+    const char * key{};
+    size_t len{0};
+    size_t offset;
+    containers container{containers::document};
+    field_type type{field_type::any};
+  };
+
+  std::vector<tweet> &tweets;
+  containers container{containers::document};
+  uint8_t *current_string_buf_loc;
+  const uint8_t *current_key{};
+
+  simdjson_really_inline bool in_container(json_iterator &iter);
+  simdjson_really_inline bool in_container_child(json_iterator &iter);
+  simdjson_really_inline void start_container(json_iterator &iter);
+  simdjson_really_inline void end_container(json_iterator &iter);
+  simdjson_really_inline error_code parse_nullable_unsigned(json_iterator &iter, const uint8_t *value, const field &f);
+  simdjson_really_inline error_code parse_unsigned(json_iterator &iter, const uint8_t *value, const field &f);
+  simdjson_really_inline error_code parse_string(json_iterator &iter, const uint8_t *value, const field &f);
+
+  struct field_lookup {
+    field entries[256]{};
+
+    field_lookup();
+    simdjson_really_inline field get(const uint8_t * key, containers container);
+  private:
+    simdjson_really_inline uint8_t hash(const char * key, uint32_t depth);
+    simdjson_really_inline void add(const char * key, size_t len, containers container, field_type type, size_t offset);
+    simdjson_really_inline void neg(const char * const key, uint32_t depth);
+  };
+  static field_lookup fields;
+}; // sax_tweet_reader_visitor
+
+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} {
+}
+
+simdjson_really_inline error_code sax_tweet_reader_visitor::visit_document_start(json_iterator &iter) {
+  start_container(iter);
+  return SUCCESS;
+}
+simdjson_really_inline error_code sax_tweet_reader_visitor::visit_array_start(json_iterator &iter) {
+  // If we're not in a container we care about, don't bother with the rest
+  if (!in_container_child(iter)) { return SUCCESS; }
+
+  // Handle fields first
+  if (current_key) {
+    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;
+      case field_type::object:
+      case field_type::unsigned_integer:
+      case field_type::nullable_unsigned_integer:
+      case field_type::string:
+        iter.log_error("unexpected array field");
+        return INCORRECT_TYPE;
+    }
+  }
+
+  // We're not in a field, so it must be a child of an array. We support any of those.
+  iter.log_error("unexpected array");
+  return INCORRECT_TYPE;
+}
+simdjson_really_inline error_code sax_tweet_reader_visitor::visit_object_start(json_iterator &iter) {
+  // If we're not in a container we care about, don't bother with the rest
+  if (!in_container_child(iter)) { return SUCCESS; }
+
+  // Handle known fields
+  if (current_key) {
+    auto f = fields.get(current_key, container);
+    switch (f.type) {
+      case field_type::object: // { "statuses": [ { "user": {
+        start_container(iter);
+        return SUCCESS;
+      case field_type::any:
+        return SUCCESS;
+      case field_type::array:
+      case field_type::unsigned_integer:
+      case field_type::nullable_unsigned_integer:
+      case field_type::string:
+        iter.log_error("unexpected object field");
+        return INCORRECT_TYPE;
+    }
+  }
+
+  // It's not a field, so it's a child of an array or document
+  switch (container) {
+    case containers::document: // top_object: {
+    case containers::statuses: // tweet:      { "statuses": [ {
+      start_container(iter);
+      return SUCCESS;
+    case containers::top_object:
+    case containers::tweet:
+    case containers::user:
+      iter.log_error("unexpected object");
+      return INCORRECT_TYPE;
+  }
+  SIMDJSON_UNREACHABLE();
+  return UNINITIALIZED;
+}
+simdjson_really_inline error_code sax_tweet_reader_visitor::visit_key(json_iterator &, const uint8_t *key) {
+  current_key = key;
+  return SUCCESS;
+}
+simdjson_really_inline error_code sax_tweet_reader_visitor::visit_primitive(json_iterator &iter, const uint8_t *value) {
+  // Don't bother unless we're in a container we care about
+  if (!in_container(iter)) { return SUCCESS; }
+
+  // Handle fields first
+  if (current_key) {
+    auto f = fields.get(current_key, container);
+    switch (f.type) {
+      case field_type::unsigned_integer:
+        return parse_unsigned(iter, value, f);
+      case field_type::nullable_unsigned_integer:
+        return parse_nullable_unsigned(iter, value, f);
+      case field_type::string:
+        return parse_string(iter, value, f);
+      case field_type::any:
+        return SUCCESS;
+      case field_type::array:
+      case field_type::object:
+        iter.log_error("unexpected primitive");
+        return INCORRECT_TYPE;
+    }
+    current_key = nullptr;
+  }
+
+  // If it's not a field, it's a child of an array.
+  // The only array we support is statuses, which must contain objects.
+  iter.log_error("unexpected primitive");
+  return INCORRECT_TYPE;
+}
+simdjson_really_inline error_code sax_tweet_reader_visitor::visit_array_end(json_iterator &iter) {
+  if (in_container(iter)) { end_container(iter); }
+  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 &) {
+  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 &) {
+  return SUCCESS;
+}
+simdjson_really_inline error_code sax_tweet_reader_visitor::visit_root_primitive(json_iterator &iter, const uint8_t *) {
+  iter.log_error("unexpected root primitive");
+  return INCORRECT_TYPE;
+}
+
+simdjson_really_inline error_code sax_tweet_reader_visitor::increment_count(json_iterator &) { return SUCCESS; }
+
+simdjson_really_inline bool sax_tweet_reader_visitor::in_container(json_iterator &iter) {
+  return iter.depth == uint32_t(container);
+}
+simdjson_really_inline bool sax_tweet_reader_visitor::in_container_child(json_iterator &iter) {
+  return iter.depth == uint32_t(container) + 1;
+}
+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_value(STATE_NAMES[iter.depth]); }
+  if (container == containers::tweet) { tweets.push_back({}); }
+}
+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);
+  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; }
+    i = 0;
+  }
+  return SUCCESS;
+}
+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);
+  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);
+  return stringparsing::parse_string_to_buffer(value, current_string_buf_loc, *s);
+}
+
+sax_tweet_reader_visitor::field_lookup sax_tweet_reader_visitor::fields{};
+
+simdjson_really_inline uint8_t sax_tweet_reader_visitor::field_lookup::hash(const char * key, uint32_t depth) {
+  // These shift numbers were chosen specifically because this yields only 2 collisions between
+  // keys in twitter.json, leaves 0 as a distinct value, and has 0 collisions between keys we
+  // actually care about.
+  return uint8_t((key[0] << 0) ^ (key[1] << 3) ^ (key[2] << 3) ^ (key[3] << 1) ^ depth);
+}
+simdjson_really_inline sax_tweet_reader_visitor::field sax_tweet_reader_visitor::field_lookup::get(const uint8_t * key, containers c) {
+  auto index = hash((const char *)key, uint32_t(c));
+  auto entry = entries[index];
+  // TODO if any key is > SIMDJSON_PADDING, this will access inaccessible memory!
+  if (c != entry.container || memcmp(key, entry.key, entry.len)) { return entries[0]; }
+  return entry;
+}
+simdjson_really_inline void sax_tweet_reader_visitor::field_lookup::add(const char * key, size_t len, containers c, field_type type, size_t offset) {
+  auto index = hash(key, uint32_t(c));
+  if (index == 0) {
+    fprintf(stderr, "%s (depth %d) hashes to zero, which is used as 'missing value'\n", key, int(c));
+    assert(false);
+  }
+  if (entries[index].key) {
+    fprintf(stderr, "%s (depth %d) collides with %s (depth %d) !\n", key, int(c), entries[index].key, int(entries[index].container));
+    assert(false);
+  }
+  entries[index] = { key, len, offset, c, type };
+}
+simdjson_really_inline void sax_tweet_reader_visitor::field_lookup::neg(const char * const key, uint32_t depth) {
+  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));
+  }
+}
+
+sax_tweet_reader_visitor::field_lookup::field_lookup() {
+  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);
+  TWEET_FIELD(favorite_count, field_type::unsigned_integer);
+  TWEET_FIELD(text, field_type::string);
+  TWEET_FIELD(created_at, field_type::string);
+  TWEET_FIELD(user, field_type::object)
+  #undef TWEET_FIELD
+  #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
+
+  // Check for collisions with other (unused) hash keys in typical twitter JSON
+  #define NEG(key, depth) neg("\"" #key "\"", depth);
+  NEG(display_url, 9);
+  NEG(expanded_url, 9);
+  neg("\"h\":", 9);
+  NEG(indices, 9);
+  NEG(resize, 9);
+  NEG(url, 9);
+  neg("\"w\":", 9);
+  NEG(display_url, 8);
+  NEG(expanded_url, 8);
+  neg("\"h\":", 8);
+  NEG(indices, 8);
+  NEG(large, 8);
+  NEG(medium, 8);
+  NEG(resize, 8);
+  NEG(small, 8);
+  NEG(thumb, 8);
+  NEG(url, 8);
+  neg("\"w\":", 8);
+  NEG(display_url, 7);
+  NEG(expanded_url, 7);
+  NEG(id_str, 7);
+  NEG(id, 7);
+  NEG(indices, 7);
+  NEG(large, 7);
+  NEG(media_url_https, 7);
+  NEG(media_url, 7);
+  NEG(medium, 7);
+  NEG(name, 7);
+  NEG(sizes, 7);
+  NEG(small, 7);
+  NEG(source_status_id_str, 7);
+  NEG(source_status_id, 7);
+  NEG(thumb, 7);
+  NEG(type, 7);
+  NEG(url, 7);
+  NEG(urls, 7);
+  NEG(description, 6);
+  NEG(display_url, 6);
+  NEG(expanded_url, 6);
+  NEG(id_str, 6);
+  NEG(id, 6);
+  NEG(indices, 6);
+  NEG(media_url_https, 6);
+  NEG(media_url, 6);
+  NEG(name, 6);
+  NEG(sizes, 6);
+  NEG(source_status_id_str, 6);
+  NEG(source_status_id, 6);
+  NEG(type, 6);
+  NEG(url, 6);
+  NEG(urls, 6);
+  NEG(contributors_enabled, 5);
+  NEG(default_profile_image, 5);
+  NEG(default_profile, 5);
+  NEG(description, 5);
+  NEG(entities, 5);
+  NEG(favourites_count, 5);
+  NEG(follow_request_sent, 5);
+  NEG(followers_count, 5);
+  NEG(following, 5);
+  NEG(friends_count, 5);
+  NEG(geo_enabled, 5);
+  NEG(hashtags, 5);
+  NEG(id_str, 5);
+  NEG(id, 5);
+  NEG(is_translation_enabled, 5);
+  NEG(is_translator, 5);
+  NEG(iso_language_code, 5);
+  NEG(lang, 5);
+  NEG(listed_count, 5);
+  NEG(location, 5);
+  NEG(media, 5);
+  NEG(name, 5);
+  NEG(notifications, 5);
+  NEG(profile_background_color, 5);
+  NEG(profile_background_image_url_https, 5);
+  NEG(profile_background_image_url, 5);
+  NEG(profile_background_tile, 5);
+  NEG(profile_banner_url, 5);
+  NEG(profile_image_url_https, 5);
+  NEG(profile_image_url, 5);
+  NEG(profile_link_color, 5);
+  NEG(profile_sidebar_border_color, 5);
+  NEG(profile_sidebar_fill_color, 5);
+  NEG(profile_text_color, 5);
+  NEG(profile_use_background_image, 5);
+  NEG(protected, 5);
+  NEG(result_type, 5);
+  NEG(statuses_count, 5);
+  NEG(symbols, 5);
+  NEG(time_zone, 5);
+  NEG(url, 5);
+  NEG(urls, 5);
+  NEG(user_mentions, 5);
+  NEG(utc_offset, 5);
+  NEG(verified, 5);
+  NEG(contributors_enabled, 4);
+  NEG(contributors, 4);
+  NEG(coordinates, 4);
+  NEG(default_profile_image, 4);
+  NEG(default_profile, 4);
+  NEG(description, 4);
+  NEG(entities, 4);
+  NEG(favorited, 4);
+  NEG(favourites_count, 4);
+  NEG(follow_request_sent, 4);
+  NEG(followers_count, 4);
+  NEG(following, 4);
+  NEG(friends_count, 4);
+  NEG(geo_enabled, 4);
+  NEG(geo, 4);
+  NEG(hashtags, 4);
+  NEG(id_str, 4);
+  NEG(in_reply_to_screen_name, 4);
+  NEG(in_reply_to_status_id_str, 4);
+  NEG(in_reply_to_user_id_str, 4);
+  NEG(in_reply_to_user_id, 4);
+  NEG(is_translation_enabled, 4);
+  NEG(is_translator, 4);
+  NEG(iso_language_code, 4);
+  NEG(lang, 4);
+  NEG(listed_count, 4);
+  NEG(location, 4);
+  NEG(media, 4);
+  NEG(metadata, 4);
+  NEG(name, 4);
+  NEG(notifications, 4);
+  NEG(place, 4);
+  NEG(possibly_sensitive, 4);
+  NEG(profile_background_color, 4);
+  NEG(profile_background_image_url_https, 4);
+  NEG(profile_background_image_url, 4);
+  NEG(profile_background_tile, 4);
+  NEG(profile_banner_url, 4);
+  NEG(profile_image_url_https, 4);
+  NEG(profile_image_url, 4);
+  NEG(profile_link_color, 4);
+  NEG(profile_sidebar_border_color, 4);
+  NEG(profile_sidebar_fill_color, 4);
+  NEG(profile_text_color, 4);
+  NEG(profile_use_background_image, 4);
+  NEG(protected, 4);
+  NEG(result_type, 4);
+  NEG(retweeted, 4);
+  NEG(source, 4);
+  NEG(statuses_count, 4);
+  NEG(symbols, 4);
+  NEG(time_zone, 4);
+  NEG(truncated, 4);
+  NEG(url, 4);
+  NEG(urls, 4);
+  NEG(user_mentions, 4);
+  NEG(utc_offset, 4);
+  NEG(verified, 4);
+  NEG(contributors, 3);
+  NEG(coordinates, 3);
+  NEG(entities, 3);
+  NEG(favorited, 3);
+  NEG(geo, 3);
+  NEG(id_str, 3);
+  NEG(in_reply_to_screen_name, 3);
+  NEG(in_reply_to_status_id_str, 3);
+  NEG(in_reply_to_user_id_str, 3);
+  NEG(in_reply_to_user_id, 3);
+  NEG(lang, 3);
+  NEG(metadata, 3);
+  NEG(place, 3);
+  NEG(possibly_sensitive, 3);
+  NEG(retweeted_status, 3);
+  NEG(retweeted, 3);
+  NEG(source, 3);
+  NEG(truncated, 3);
+  NEG(completed_in, 2);
+  NEG(count, 2);
+  NEG(max_id_str, 2);
+  NEG(max_id, 2);
+  NEG(next_results, 2);
+  NEG(query, 2);
+  NEG(refresh_url, 2);
+  NEG(since_id_str, 2);
+  NEG(since_id, 2);
+  NEG(search_metadata, 1);
+  #undef NEG
+}
+
+// sax_tweet_reader_visitor::field_lookup::find_min() {
+//   int min_count = 100000;
+//   for (int a=0;a<4;a++) {
+//     for (int b=0;b<4;b++) {
+//       for (int c=0;c<4;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); }
+//       }
+//     }
+//   }
+// }
+
+} // 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
@@ -29,9 +29,10 @@ std::string exec(const char* cmd) {
    std::string result;
    std::unique_ptr<FILE, decltype(&closepipe)> pipe(popen(cmd, "r"), closepipe);
    if (!pipe) {
-        throw std::runtime_error("popen() failed!");
+        std::cerr << "popen() failed!" << std::endl;
+        abort();
    }
-    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
+    while (fgets(buffer.data(), int(buffer.size()), pipe.get()) != nullptr) {
        result += buffer.data();
    }
    return result;
@@ -43,10 +44,10 @@ double readThroughput(std::string parseOutput) {
    double result = 0;
    int numResults = 0;
    while (std::getline(output, line)) {
-        int pos = 0;
+        std::string::size_type pos = 0;
        for (int i=0; i<5; i++) {
            pos = line.find('\t', pos);
-            if (pos < 0) {
+            if (pos == std::string::npos) {
                std::cerr << "Command printed out a line with less than 5 fields in it:\n" << line << std::endl;
            }
            pos++;
@@ -63,23 +64,33 @@ double readThroughput(std::string parseOutput) {

 const double INTERLEAVED_ATTEMPTS = 7;

-int main(int argc, char *argv[]) {
-    if (argc != 3) {
-        std::cerr << "Usage: " << argv[0] << " <new parse cmd> <reference parse cmd>" << std::endl;
+int main(int argc, const char *argv[]) {
+    if (argc < 3) {
+        std::cerr << "Usage: " << argv[0] << " <old parse exe> <new parse exe> [<parse arguments>]" << std::endl;
        return 1;
    }
+
+    std::string newCommand = argv[1];
+    std::string refCommand = argv[2];
+    for (int i=3; i<argc; i++) {
+        newCommand += " ";
+        newCommand += argv[i];
+        refCommand += " ";
+        refCommand += argv[i];
+    }
+
    std::vector<double> ref;
    std::vector<double> newcode;
    for (int attempt=0; attempt < INTERLEAVED_ATTEMPTS; attempt++) {
        std::cout << "Attempt #" << (attempt+1) << " of " << INTERLEAVED_ATTEMPTS << std::endl;

        // Read new throughput
-        double newThroughput = readThroughput(exec(argv[1]));
+        double newThroughput = readThroughput(exec(newCommand.c_str()));
        std::cout << "New throughput: " << newThroughput << std::endl;
        newcode.push_back(newThroughput);

        // Read reference throughput
-        double referenceThroughput = readThroughput(exec(argv[2]));
+        double referenceThroughput = readThroughput(exec(refCommand.c_str()));
        std::cout << "Ref throughput: " << referenceThroughput << std::endl;
        ref.push_back(referenceThroughput);
    }
@@ -1,7 +1,5 @@
 #include <iostream>
-#ifndef _MSC_VER
 #include <unistd.h>
-#endif
 #include "simdjson.h"
 #ifdef __linux__
 #include "linux-perf-events.h"
@@ -43,7 +41,7 @@ using stat_t = struct stat_s;



-really_inline void simdjson_process_atom(stat_t &s,
+simdjson_really_inline void simdjson_process_atom(stat_t &s,
                                         simdjson::dom::element element) {
  if (element.is<int64_t>()) {
    s.integer_count++;
@@ -52,7 +50,10 @@ really_inline void simdjson_process_atom(stat_t &s,
  } else if(element.is<double>()) {
    s.float_count++;
  } else if (element.is<bool>()) {
-    if (element.get<bool>()) {
+    simdjson::error_code err;
+    bool v;
+    err = element.get(v);
+    if (v) {
      s.true_count++;
    } else {
      s.false_count++;
@@ -63,9 +64,11 @@ really_inline void simdjson_process_atom(stat_t &s,
 }

 void simdjson_recurse(stat_t &s, simdjson::dom::element element) {
+  simdjson::error_code error;
  if (element.is<simdjson::dom::array>()) {
    s.array_count++;
-    auto [array, array_error] = element.get<simdjson::dom::array>();
+    simdjson::dom::array array;
+    if ((error = element.get(array))) { std::cerr << error << std::endl; abort(); }
    for (auto child : array) {
      if (child.is<simdjson::dom::array>() || child.is<simdjson::dom::object>()) {
        simdjson_recurse(s, child);
@@ -75,13 +78,14 @@ void simdjson_recurse(stat_t &s, simdjson::dom::element element) {
    }
  } else if (element.is<simdjson::dom::object>()) {
    s.object_count++;
-    auto [object, object_error] = element.get<simdjson::dom::object>();
-    for (auto [key, value] : object) {
+    simdjson::dom::object object;
+    if ((error = element.get(object))) { std::cerr << error << std::endl; abort(); }
+    for (auto field : object) {
      s.string_count++; // for key
-      if (value.is<simdjson::dom::array>() || value.is<simdjson::dom::object>()) {
-        simdjson_recurse(s, value);
+      if (field.value.is<simdjson::dom::array>() || field.value.is<simdjson::dom::object>()) {
+        simdjson_recurse(s, field.value);
      } else {
-        simdjson_process_atom(s, value);
+        simdjson_process_atom(s, field.value);
      }
    }
  } else {
@@ -92,7 +96,8 @@ void simdjson_recurse(stat_t &s, simdjson::dom::element element) {
 stat_t simdjson_compute_stats(const simdjson::padded_string &p) {
  stat_t answer{};
  simdjson::dom::parser parser;
-  auto [doc, error] = parser.parse(p);
+  simdjson::dom::element doc;
+  auto error = parser.parse(p).get(doc);
  if (error) {
    answer.valid = false;
    return answer;
@@ -103,7 +108,7 @@ stat_t simdjson_compute_stats(const simdjson::padded_string &p) {
  answer.non_ascii_byte_count = count_nonasciibytes(
      reinterpret_cast<const uint8_t *>(p.data()), p.size());
  answer.byte_count = p.size();
-  answer.structural_indexes_count = parser.n_structural_indexes;
+  answer.structural_indexes_count = parser.implementation->n_structural_indexes;
  simdjson_recurse(answer, doc);
  return answer;
 }
@@ -132,7 +137,8 @@ int main(int argc, char *argv[]) {
    std::cerr << "warning: ignoring everything after " << argv[optind + 1]
              << std::endl;
  }
-  auto [p, error] = simdjson::padded_string::load(filename);
+  simdjson::padded_string p;
+  auto error = simdjson::padded_string::load(filename).get(p);
  if (error) {
    std::cerr << "Could not load the file " << filename << std::endl;
    return EXIT_FAILURE;
@@ -160,7 +166,6 @@ int main(int argc, char *argv[]) {
         s.true_count, s.false_count, s.byte_count, s.structural_indexes_count);
 #ifdef __linux__
  simdjson::dom::parser parser;
-  const simdjson::implementation &stage_parser = *simdjson::active_implementation;
  simdjson::error_code alloc_error = parser.allocate(p.size());
  if (alloc_error) {
    std::cerr << alloc_error << std::endl;
@@ -178,14 +183,14 @@ int main(int argc, char *argv[]) {
  for (uint32_t i = 0; i < iterations; i++) {
    unified.start();
    // The default template is simdjson::architecture::NATIVE.
-    bool isok = (stage_parser.stage1((const uint8_t *)p.data(), p.size(), parser, false) == simdjson::SUCCESS);
+    bool isok = (parser.implementation->stage1((const uint8_t *)p.data(), p.size(), false) == simdjson::SUCCESS);
    unified.end(results);

    cy1 += results[0];
    cl1 += results[1];

    unified.start();
-    isok = isok && (stage_parser.stage2((const uint8_t *)p.data(), p.size(), parser) == simdjson::SUCCESS);
+    isok = isok && (parser.implementation->stage2(parser.doc) == simdjson::SUCCESS);
    unified.end(results);

    cy2 += results[0];
@@ -194,8 +199,8 @@ int main(int argc, char *argv[]) {
      std::cerr << "failure?" << std::endl;
    }
  }
-  printf("%f %f %f %f ", cy1 * 1.0 / iterations, cl1 * 1.0 / iterations,
-         cy2 * 1.0 / iterations, cl2 * 1.0 / iterations);
+  printf("%f %f %f %f ", static_cast<double>(cy1) / static_cast<double>(iterations), static_cast<double>(cl1) / static_cast<double>(iterations),
+         static_cast<double>(cy2) / static_cast<double>(iterations), static_cast<double>(cl2) / static_cast<double>(iterations));
 #endif // __linux__
  printf("\n");
  return EXIT_SUCCESS;
@@ -0,0 +1,49 @@
+# Helper so we don't have to repeat ourselves so much
+# Usage: add_cpp_test(testname [COMPILE_ONLY] [SOURCES a.cpp b.cpp ...] [LABELS acceptance per_implementation ...])
+# SOURCES defaults to testname.cpp if not specified.
+function(add_cpp_test TEST_NAME)
+  # Parse arguments
+  cmake_parse_arguments(PARSE_ARGV 1 ARGS "COMPILE_ONLY;LIBRARY;WILL_FAIL" "" "SOURCES;LABELS")
+  if (NOT ARGS_SOURCES)
+    list(APPEND ARGS_SOURCES ${TEST_NAME}.cpp)
+  endif()
+  if (ARGS_COMPILE_ONLY)
+    list(APPEND ${ARGS_LABELS} compile)
+  endif()
+
+  # Add the compile target
+  if (ARGS_LIBRARY)
+    add_library(${TEST_NAME} STATIC ${ARGS_SOURCES})
+  else(ARGS_LIBRARY)
+    add_executable(${TEST_NAME} ${ARGS_SOURCES})
+  endif(ARGS_LIBRARY)
+
+  # Add test
+  if (ARGS_COMPILE_ONLY OR ARGS_LIBRARY)
+    add_test(
+      NAME ${TEST_NAME}
+      COMMAND ${CMAKE_COMMAND} --build . --target ${TEST_NAME} --config $<CONFIGURATION>
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+    set_target_properties(${TEST_NAME} PROPERTIES EXCLUDE_FROM_ALL TRUE EXCLUDE_FROM_DEFAULT_BUILD TRUE)
+  else()
+    add_test(${TEST_NAME} ${TEST_NAME})
+  endif()
+
+  if (ARGS_LABELS)
+    set_property(TEST ${TEST_NAME} APPEND PROPERTY LABELS ${ARGS_LABELS})
+  endif()
+
+  if (ARGS_WILL_FAIL)
+    set_property(TEST ${TEST_NAME} PROPERTY WILL_FAIL TRUE)
+  endif()
+endfunction()
+
+function(add_compile_only_test TEST_NAME)
+  add_test(
+    NAME ${TEST_NAME}
+    COMMAND ${CMAKE_COMMAND} --build . --target ${TEST_NAME} --config $<CONFIGURATION>
+    WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+  )
+  set_target_properties(${TEST_NAME} PROPERTIES EXCLUDE_FROM_ALL TRUE EXCLUDE_FROM_DEFAULT_BUILD TRUE)
+endfunction()
@@ -0,0 +1,221 @@
+
+if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+  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()
+  message (STATUS "The simdjson repository appears to be used as a subdirectory.")
+  option(SIMDJSON_JUST_LIBRARY "Build just the library, omit tests, tools and benchmarks" ON)
+  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)
+#
+add_library(simdjson-flags INTERFACE)
+add_library(simdjson-internal-flags INTERFACE)
+target_link_libraries(simdjson-internal-flags INTERFACE simdjson-flags)
+
+option(SIMDJSON_SANITIZE "Sanitize addresses" OFF)
+if(SIMDJSON_SANITIZE)
+  target_compile_options(simdjson-flags INTERFACE -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined -fno-sanitize-recover=all)
+  target_link_libraries(simdjson-flags INTERFACE -fsanitize=address -fno-omit-frame-pointer -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")
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+  if(SIMDJSON_SANITIZE)
+    message(WARNING "No build type selected and you have enabled the sanitizer. Consider setting CMAKE_BUILD_TYPE to Debug to help identify the eventual problems.")
+  endif()
+endif()
+
+if(MSVC)
+  option(SIMDJSON_BUILD_STATIC "Build a static library" ON) # turning it on disables the production of a dynamic library
+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")
+
+# We compile tools, tests, etc. with C++ 17. Override yourself if you need on a target.
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_MACOSX_RPATH OFF)
+set(CMAKE_THREAD_PREFER_PTHREAD ON)
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+
+# LTO seems to create all sorts of fun problems. Let us
+# disable temporarily.
+#include(CheckIPOSupported)
+#check_ipo_supported(RESULT ltoresult)
+#if(ltoresult)
+#  set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+#endif()
+
+option(SIMDJSON_VISUAL_STUDIO_BUILD_WITH_DEBUG_INFO_FOR_PROFILING "Under Visual Studio, add Zi to the compile flag and DEBUG to the link file to add debugging information to the release build for easier profiling inside tools like VTune" OFF)
+if(MSVC)
+if("${MSVC_TOOLSET_VERSION}" STREQUAL "140")
+  # Visual Studio 2015 issues warnings and we tolerate it,  cmake -G"Visual Studio 14" ..
+  target_compile_options(simdjson-internal-flags INTERFACE /W0 /sdl)
+else()
+  # Recent version of Visual Studio expected (2017, 2019...). Prior versions are unsupported.
+  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_compile_options(simdjson-flags INTERFACE  /Zi)
+endif()
+else()
+  target_compile_options(simdjson-internal-flags INTERFACE -fPIC)
+  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")
+
+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/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)
+  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)
+  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)
+  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_FALLBACK "Include the fallback implementation" ON)
+if(NOT SIMDJSON_IMPLEMENTATION_FALLBACK)
+  message(DEPRECATION "SIMDJSON_IMPLEMENTATION_FALLBACK is deprecated. Use SIMDJSON_IMPLEMENTATION=-fallback instead.")
+  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_IMPLEMENTATION_FALLBACK=0)
+endif()
+
+#
+# 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_BASH "Allow usage of bash within CMake" ON)
+
+option(SIMDJSON_GIT "Allow usage of git 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-flags INTERFACE SIMDJSON_EXCEPTIONS=0)
+endif()
+
+option(SIMDJSON_ENABLE_THREADS "Link with thread support" ON)
+if(SIMDJSON_ENABLE_THREADS)
+  set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
+  set(THREADS_PREFER_PTHREAD_FLAG TRUE)
+  find_package(Threads REQUIRED)
+  target_link_libraries(simdjson-flags INTERFACE Threads::Threads)
+  target_link_libraries(simdjson-flags INTERFACE ${CMAKE_THREAD_LIBS_INIT})
+  target_compile_options(simdjson-flags INTERFACE ${CMAKE_THREAD_LIBS_INIT})
+  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()
+
+if(SIMDJSON_USE_LIBCPP)
+  target_link_libraries(simdjson-flags INTERFACE -stdlib=libc++ -lc++abi)
+  # instead of the above line, we could have used
+  # set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++  -lc++abi")
+  # The next line is needed empirically.
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+  # we update CMAKE_SHARED_LINKER_FLAGS, this gets updated later as well
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -lc++abi")
+endif(SIMDJSON_USE_LIBCPP)
+
+# prevent shared libraries from depending on Intel provided libraries
+if(${CMAKE_C_COMPILER_ID} MATCHES "Intel") # icc / icpc
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static-intel")
+endif()
+
+install(TARGETS simdjson-flags EXPORT simdjson-config)
+install(TARGETS simdjson-internal-flags EXPORT simdjson-config)
@@ -0,0 +1,24 @@
+#
+# ${SIMDJSON_USER_CMAKECACHE} contains the *user-specified* simdjson options so you can call cmake on
+# another branch or repository with the same options.
+#
+# Not supported on Windows at present, because the only thing that uses it is checkperf, which we
+# don't run on Windows.
+#
+set(SIMDJSON_USER_CMAKECACHE ${CMAKE_CURRENT_BINARY_DIR}/.simdjson-user-CMakeCache.txt)
+if (MSVC)
+  add_custom_command(
+    OUTPUT ${SIMDJSON_USER_CMAKECACHE}
+    COMMAND findstr SIMDJSON_ ${PROJECT_BINARY_DIR}/CMakeCache.txt > ${SIMDJSON_USER_CMAKECACHE}.tmp
+    COMMAND findstr /v SIMDJSON_LIB_ ${SIMDJSON_USER_CMAKECACHE}.tmp > ${SIMDJSON_USER_CMAKECACHE}
+    VERBATIM # Makes it not do weird escaping with the command
+  )
+else()
+  add_custom_command(
+    OUTPUT ${SIMDJSON_USER_CMAKECACHE}
+    COMMAND grep SIMDJSON_ ${PROJECT_BINARY_DIR}/CMakeCache.txt > ${SIMDJSON_USER_CMAKECACHE}.tmp
+    COMMAND grep -v SIMDJSON_LIB_ ${SIMDJSON_USER_CMAKECACHE}.tmp > ${SIMDJSON_USER_CMAKECACHE}
+    VERBATIM # Makes it not do weird escaping with the command
+  )
+endif()
+add_custom_target(simdjson-user-cmakecache DEPENDS ${SIMDJSON_USER_CMAKECACHE})
@@ -0,0 +1,98 @@
+# Initializes a git submodule if it hasn't been initialized before
+
+
+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)
+    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)
+  endif()
+
+  if (SIMDJSON_COMPETITION)
+    initialize_submodule(cJSON)
+    add_library(competition-cJSON INTERFACE)
+    target_include_directories(competition-cJSON INTERFACE cJSON)
+
+    initialize_submodule(fastjson)
+    add_library(competition-fastjson INTERFACE)
+    target_include_directories(competition-fastjson INTERFACE fastjson/src fastjson/include)
+
+    initialize_submodule(gason)
+    add_library(competition-gason INTERFACE)
+    target_include_directories(competition-gason INTERFACE gason/src)
+
+    initialize_submodule(jsmn)
+    add_library(competition-jsmn INTERFACE)
+    target_include_directories(competition-jsmn INTERFACE jsmn)
+
+    initialize_submodule(json)
+    add_library(competition-json INTERFACE)
+    target_include_directories(competition-json INTERFACE json/single_include)
+
+    initialize_submodule(json11)
+    add_library(competition-json11 INTERFACE)
+    target_include_directories(competition-json11 INTERFACE json11)
+
+    add_library(competition-jsoncppdist INTERFACE)
+    target_include_directories(competition-jsoncppdist INTERFACE jsoncppdist)
+
+    initialize_submodule(rapidjson)
+    add_library(competition-rapidjson INTERFACE)
+    target_include_directories(competition-rapidjson INTERFACE rapidjson/include)
+
+    initialize_submodule(sajson)
+    add_library(competition-sajson INTERFACE)
+    target_include_directories(competition-sajson INTERFACE sajson/include)
+
+    initialize_submodule(ujson4c)
+    add_library(competition-ujson4c ujson4c/src/ujdecode.c)
+    target_include_directories(competition-ujson4c PUBLIC ujson4c/3rdparty ujson4c/src)
+
+    initialize_submodule(boost.json)
+    add_library(boostjson boost.json/src/src.cpp)
+    target_compile_definitions(boostjson PUBLIC BOOST_JSON_STANDALONE)
+    target_include_directories(boostjson PUBLIC boost.json/include)
+
+    initialize_submodule(yyjson)
+    add_library(yyjson yyjson/src/yyjson.c)
+    target_include_directories(yyjson PUBLIC yyjson/src)
+
+    add_library(competition-core INTERFACE)
+    target_link_libraries(competition-core INTERFACE competition-json competition-rapidjson competition-sajson competition-cJSON competition-jsmn boostjson yyjson)
+
+    add_library(competition-all INTERFACE)
+    target_link_libraries(competition-all INTERFACE competition-core competition-jsoncppdist competition-json11 competition-fastjson competition-gason competition-ujson4c)
+  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()
@@ -3,9 +3,15 @@ The Basics

 An overview of what you need to know to use simdjson, with examples.

+* [Requirements](#requirements)
 * [Including simdjson](#including-simdjson)
+* [Using simdjson as a CMake dependency](#using-simdjson-as-a-cmake-dependency)
 * [The Basics: Loading and Parsing JSON Documents](#the-basics-loading-and-parsing-json-documents)
 * [Using the Parsed JSON](#using-the-parsed-json)
+* [C++11 Support and string_view](#c11-support-and-string_view)
+* [C++17 Support](#c17-support)
+* [Minifying JSON strings without parsing](#minifying-json-strings-without-parsing)
+* [UTF-8 validation (alone)](#utf-8-validation-alone)
 * [JSON Pointer](#json-pointer)
 * [Error Handling](#error-handling)
  * [Error Handling Example](#error-handling-example)
@@ -13,6 +19,14 @@ An overview of what you need to know to use simdjson, with examples.
 * [Tree Walking and JSON Element Types](#tree-walking-and-json-element-types)
 * [Newline-Delimited JSON (ndjson) and JSON lines](#newline-delimited-json-ndjson-and-json-lines)
 * [Thread Safety](#thread-safety)
+* [Standard Compliance](#standard-compliance)
+
+
+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.
+- 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
 ------------------
@@ -28,9 +42,56 @@ using namespace simdjson; // optional
 You can compile with:

 ```
-c++ myproject.cpp simdjson.cpp --std=c++17
+c++ myproject.cpp simdjson.cpp
 ```

+Note:
+- Users on macOS and other platforms were default compilers do not provide C++11 compliant by default should request it with the appropriate flag (e.g., `c++ -std=c++17 myproject.cpp simdjson.cpp`).
+- Visual Studio users should compile with the `_CRT_SECURE_NO_WARNINGS` flag to avoid warnings with respect to our use of standard C functions such as `fopen`.
+
+
+Using simdjson with package managers
+------------------
+
+You can install the simdjson library on your system or in your project using multiple package managers such as  MSYS2, the conan package manager, vcpkg, brew, the apt package manager (debian-based Linux systems), the FreeBSD package manager (FreeBSD), and so on. [Visit our wiki for more details](https://github.com/simdjson/simdjson/wiki/Installing-simdjson-with-a-package-manager).
+
+Using simdjson as a CMake dependency
+------------------
+
+You can include the  simdjson as a CMake dependency by including the following lines in your `CMakeLists.txt`:
+
+```cmake
+include(FetchContent)
+
+FetchContent_Declare(
+  simdjson
+  GIT_REPOSITORY https://github.com/simdjson/simdjson.git
+  GIT_TAG  v0.5.0
+  GIT_SHALLOW TRUE)
+
+set(SIMDJSON_JUST_LIBRARY ON CACHE INTERNAL "")
+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, 
+
+Elsewhere in your project, you can  declare dependencies on simdjson with lines such as these:
+
+```cmake
+add_executable(myprogram myprogram.cpp)
+target_link_libraries(myprogram simdjson)
+```
+
+We recommend CMake version 3.15 or better.
+
+See [our CMake demonstration](https://github.com/simdjson/cmake_demo_single_file). It works under Linux, FreeBSD, macOS and Windows (including Visual Studio).
+
+
+
+The CMake build in simdjson can be taylored with a few variables. You can see the available variables and their default values by entering the `cmake -LA` command.
+
 The Basics: Loading and Parsing JSON Documents
 ----------------------------------------------

@@ -47,19 +108,38 @@ 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.
+
+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
 ---------------------

 Once you have an element, you can navigate it with idiomatic C++ iterators, operators and casts.

-* **Extracting Values:** You can cast a JSON element to a native type: `double(element)` or
+* **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. You can also use is_*typename*()` to test if it is a
-  given type, and as_*typename*() to do the cast and return an error code on failure instead of an
-  exception.
+  dom::object and dom::array. An exception is thrown if the cast is not possible.
+* **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;
+  simdjson::padded_string numberstring = "1.2"_padded; // our JSON input ("1.2")
+  simdjson::dom::parser parser;
+  double value; // variable where we store the value to be parsed
+  error = parser.parse(numberstring).get(value);
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+  std::cout << "I parsed " << value << " from " << numberstring.data() << std::endl;
+  ```
 * **Field Access:** To get the value of the "foo" field in an object, use `object["foo"]`.
 * **Array Iteration:** To iterate through an array, use `for (auto value : array) { ... }`. If you
  know the type of the value, you can cast it right there, too! `for (double value : array) { ... }`
@@ -67,11 +147,16 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
 * **Array Index:** To get at an array value by index, use the at() method: `array.at(0)` gets the
  first element.
  > Note that array[0] does not compile, because implementing [] gives the impression indexing is a
-  > O(1) operation, which it is not presently in simdjson.
+  > O(1) operation, which it is not presently in simdjson. Instead, you should iterate over the elements
+  > using a for-loop, as in our examples.
+* **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"( [
@@ -80,10 +165,9 @@ auto cars_json = R"( [
  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
 ] )"_padded;
 dom::parser parser;
-dom::array cars = parser.parse(cars_json).get<dom::array>();

 // Iterating through an array of objects
-for (dom::object car : cars) {
+for (dom::object car : parser.parse(cars_json)) {
  // Accessing a field by name
  cout << "Make/Model: " << car["make"] << "/" << car["model"] << endl;

@@ -99,17 +183,135 @@ for (dom::object car : cars) {
  cout << "- Average tire pressure: " << (total_tire_pressure / 4) << endl;

  // Writing out all the information about the car
-  for (auto [key, value] : car) {
-    cout << "- " << key << ": " << value << endl;
+  for (auto field : car) {
+    cout << "- " << field.key << ": " << field.value << endl;
  }
 }
 ```

+Here is a different example illustrating the same ideas:
+
+```C++
+auto abstract_json = R"( [
+    {  "12345" : {"a":12.34, "b":56.78, "c": 9998877}   },
+    {  "12545" : {"a":11.44, "b":12.78, "c": 11111111}  }
+  ] )"_padded;
+dom::parser parser;
+
+// Parse and iterate through an array of objects
+for (dom::object obj : parser.parse(abstract_json)) {
+    for(const auto& key_value : obj) {
+      cout << "key: " << key_value.key << " : ";
+      dom::object innerobj = key_value.value;
+      cout << "a: " << double(innerobj["a"]) << ", ";
+      cout << "b: " << double(innerobj["b"]) << ", ";
+      cout << "c: " << int64_t(innerobj["c"]) << endl;
+    }
+}
+```
+
+And another one:
+
+
+```C++
+  auto abstract_json = R"(
+    {  "str" : { "123" : {"abc" : 3.14 } } } )"_padded;
+  dom::parser parser;
+  double v = parser.parse(abstract_json)["str"]["123"]["abc"];
+  cout << "number: " << v << endl;
+```
+
+
+C++11 Support and string_view
+-------------
+
+The simdjson library builds on compilers supporting the [C++11 standard](https://en.wikipedia.org/wiki/C%2B%2B11). It is also a strict requirement: we have no plan to support older C++ compilers.
+
+We represent parsed strings in simdjson using the `std::string_view` class. It avoids
+the need to copy the data, as would be necessary with the `std::string` class. It also
+avoids the pitfalls of null-terminated C strings.
+
+The `std::string_view` class has become standard as part of C++17 but it is not always available
+on compilers which only supports C++11. When we detect that `string_view` is natively
+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  
+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`.
+
+
+C++17 Support
+-------------
+
+While the simdjson library can be used in any project using C++ 11 and above, field iteration has special support C++ 17's destructuring syntax. For example:
+
+```c++
+padded_string json = R"(  { "foo": 1, "bar": 2 }  )"_padded;
+dom::parser parser;
+dom::object object;
+auto error = parser.parse(json).get(object);
+if (error) { cerr << error << endl; return; }
+for (auto [key, value] : object) {
+  cout << key << " = " << value << endl;
+}
+```
+
+For comparison, here is the C++ 11 version of the same code:
+
+```c++
+// C++ 11 version for comparison
+padded_string json = R"(  { "foo": 1, "bar": 2 }  )"_padded;
+dom::parser parser;
+dom::object object;
+auto error = parser.parse(json).get(object);
+if (error) { cerr << error << endl; return; }
+for (dom::key_value_pair field : object) {
+  cout << field.key << " = " << field.value << endl;
+}
+```
+
+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 (`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 = 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.
+```
+
+Though it does not validate the JSON input, it will detect when the document ends with an unterminated string. E.g., it would refuse to minify the string `"this string is not terminated` because of the missing final quote.
+
+
+UTF-8 validation (alone)
+----------------------
+
+The simdjson library has fast functions to validate UTF-8 strings. They are many times faster than most functions commonly found in libraries. You can use our fast functions, even if you do not care about JSON.
+
+```C++
+  const char * some_string = "[ 1, 2, 3, 4] ";
+  size_t length = std::strlen(some_string);
+  bool is_ok = simdjson::validate_utf8(some_string, length);
+```
+
+The UTF-8 validation function merely checks that the input is valid UTF-8: it works with strings in general, not just JSON strings.
+
+Your input string does not need any padding. Any string will do. The `validate_utf8` function does not do any memory allocation on the heap, and it does not throw exceptions.
+
 JSON Pointer
 ------------

 The simdjson library also supports [JSON pointer](https://tools.ietf.org/html/rfc6901) through the
-at() method, letting you reach further down into the document in a single call:
+`at_pointer()` method, letting you reach further down into the document in a single call:

 ```c++
 auto cars_json = R"( [
@@ -119,35 +321,75 @@ auto cars_json = R"( [
 ] )"_padded;
 dom::parser parser;
 dom::element cars = parser.parse(cars_json);
-cout << cars.at("0/tire_pressure/1") << endl; // Prints 39.9
+cout << cars.at_pointer("/0/tire_pressure/1") << endl; // Prints 39.9
 ```

+A JSON Path is a sequence of segments each starting with the '/' character. Within arrays, an integer
+index allows you to select the indexed node. Within objects, the string value of the key allows you to
+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.  
+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: 
+
+```c++
+auto cars_json = R"( [
+  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
+  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
+  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
+] )"_padded;
+dom::parser parser;
+dom::element cars = parser.parse(cars_json);
+cout << cars.at_pointer("/0/tire_pressure/1") << endl; // Prints 39.9
+for (dom::element car_element : cars) {
+    dom::object car;
+    simdjson::error_code error;
+    if ((error = car_element.get(car))) { std::cerr << error << std::endl; return; }
+    double x = car.at_pointer("/tire_pressure/1");
+    cout << x << endl; // Prints 39.9, 31 and 30
+}
+```
+
+
+
 Error Handling
 --------------

 All simdjson APIs that can fail return `simdjson_result<T>`, which is a &lt;value, error_code&gt;
-pair. The error codes and values can be accessed directly, reading the error like so:
+pair. You can retrieve the value with .get(), like so:

 ```c++
-auto [doc, error] = parser.parse(json); // doc is a dom::element
+dom::element doc;
+auto error = parser.parse(json).get(doc);
 if (error) { cerr << error << endl; exit(1); }
-// Use document here now that we've checked for the error
 ```

 When you use the code this way, it is your responsibility to check for error before using the
 result: if there is an error, the result value will not be valid and using it will caused undefined
 behavior.

-> Note: because of the way `auto [x, y]` works in C++, you have to define new variables each time you
-> use it. If your project treats aliased, this means you can't use the same names in `auto [x, error]`
-> without triggering warnings or error (and particularly can't use the word "error" every time). To
-> circumvent this, you can use this instead:
-> 
-> ```c++
-> dom::element doc;
-> simdjson::error_code error;
-> parser.parse(json).tie(doc, error); // <-- Assigns to doc and error just like "auto [doc, error]"
-> ```
+We can write a "quick start" example where we attempt to parse a file and access some data, without triggering exceptions:
+
+```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; }
+
+  simdjson::dom::element res;
+  if ((error = tweets["search_metadata"]["count"].get(res))) {
+    std::cerr << "could not access keys" << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout << res << " results." << std::endl;
+}
+```

 ### Error Handling Example

@@ -160,45 +402,112 @@ auto cars_json = R"( [
  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
 ] )"_padded;
 dom::parser parser;
-auto [cars, error] = parser.parse(cars_json).get<dom::array>();
+dom::array cars;
+auto error = parser.parse(cars_json).get(cars);
 if (error) { cerr << error << endl; exit(1); }

 // Iterating through an array of objects
 for (dom::element car_element : cars) {
-dom::object car;
-car_element.get<dom::object>().tie(car, error);
-if (error) { cerr << error << endl; exit(1); }
+    dom::object car;
+    if ((error = car_element.get(car))) { cerr << error << endl; exit(1); }

-// Accessing a field by name
-dom::element make, model;
-car["make"].tie(make, error);
-if (error) { cerr << error << endl; exit(1); }
-car["model"].tie(model, error);
-if (error) { cerr << error << endl; exit(1); }
-cout << "Make/Model: " << make << "/" << model << endl;
+    // Accessing a field by name
+    std::string_view make, model;
+    if ((error = car["make"].get(make))) { cerr << error << endl; exit(1); }
+    if ((error = car["model"].get(model))) { cerr << error << endl; exit(1); }
+    cout << "Make/Model: " << make << "/" << model << endl;

-// Casting a JSON element to an integer
-uint64_t year;
-car["year"].get<uint64_t>().tie(year, error);
-if (error) { cerr << error << endl; exit(1); }
-cout << "- This car is " << 2020 - year << "years old." << endl;
+    // Casting a JSON element to an integer
+    uint64_t year;
+    if ((error = car["year"].get(year))) { cerr << error << endl; exit(1); }
+    cout << "- This car is " << 2020 - year << "years old." << endl;

-// Iterating through an array of floats
-double total_tire_pressure = 0;
-dom::array tire_pressure_array;
-car["tire_pressure"].get<dom::array>().tie(tire_pressure_array, error);
-if (error) { cerr << error << endl; exit(1); }
-for (dom::element tire_pressure_element : tire_pressure_array) {
-    double tire_pressure;
-    tire_pressure_element.get<double>().tie(tire_pressure, error);
-    if (error) { cerr << error << endl; exit(1); }
-    total_tire_pressure += tire_pressure;
+    // Iterating through an array of floats
+    double total_tire_pressure = 0;
+    dom::array tire_pressure_array;
+    if ((error = car["tire_pressure"].get(tire_pressure_array))) { cerr << error << endl; exit(1); }
+    for (dom::element tire_pressure_element : tire_pressure_array) {
+        double tire_pressure;
+        if ((error = tire_pressure_element.get(tire_pressure))) { cerr << error << endl; exit(1); }
+        total_tire_pressure += tire_pressure;
+    }
+    cout << "- Average tire pressure: " << (total_tire_pressure / 4) << endl;
+
+    // Writing out all the information about the car
+    for (auto field : car) {
+        cout << "- " << field.key << ": " << field.value << endl;
+    }
 }
-cout << "- Average tire pressure: " << (total_tire_pressure / 4) << endl;
+```

-// Writing out all the information about the car
-for (auto [key, value] : car) {
-    cout << "- " << key << ": " << value << endl;
+Here is another example:
+
+```C++
+auto abstract_json = R"( [
+    {  "12345" : {"a":12.34, "b":56.78, "c": 9998877}   },
+    {  "12545" : {"a":11.44, "b":12.78, "c": 11111111}  }
+  ] )"_padded;
+dom::parser parser;
+dom::array array;
+auto error = parser.parse(abstract_json).get(array);
+if (error) { cerr << error << endl; exit(1); }
+// Iterate through an array of objects
+for (dom::element elem : array) {
+    dom::object obj;
+    if ((error = elem.get(obj))) { cerr << error << endl; exit(1); }
+    for (auto & key_value : obj) {
+        cout << "key: " << key_value.key << " : ";
+        dom::object innerobj;
+        if ((error = key_value.value.get(innerobj))) { cerr << error << endl; exit(1); }
+
+        double va, vb;
+        if ((error = innerobj["a"].get(va))) { cerr << error << endl; exit(1); }
+        cout << "a: " << va << ", ";
+        if ((error = innerobj["b"].get(vc))) { cerr << error << endl; exit(1); }
+        cout << "b: " << vb << ", ";
+
+        int64_t vc;
+        if ((error = innerobj["c"].get(vc))) { cerr << error << endl; exit(1); }
+        cout << "c: " << vc << endl;
+    }
+}
+```
+
+And another one:
+
+```C++
+  auto abstract_json = R"(
+    {  "str" : { "123" : {"abc" : 3.14 } } } )"_padded;
+  dom::parser parser;
+  double v;
+  auto error = parser.parse(abstract_json)["str"]["123"]["abc"].get(v);
+  if (error) { cerr << error << endl; exit(1); }
+  cout << "number: " << v << endl;
+```
+
+Notice how we can string several operations (`parser.parse(abstract_json)["str"]["123"]["abc"].get(v)`) and only check for the error once, a strategy we call  *error chaining*.
+
+The next two functions will take as input a JSON document containing an array with a single element, either a string or a number. They return true upon success.
+
+```C++
+simdjson::dom::parser parser{};
+
+bool parse_double(const char *j, double &d) {
+  auto error = parser.parse(j, std::strlen(j))
+        .at(0)
+        .get(d, error);
+  if (error) { return false; }
+  return true;
+}
+
+bool parse_string(const char *j, std::string &s) {
+  std::string_view answer;
+  auto error = parser.parse(j,strlen(j))
+        .at(0)
+        .get(answer, error);
+  if (error) { return false; }
+  s.assign(answer.data(), answer.size());
+  return true;
 }
 ```

@@ -274,9 +583,9 @@ The simdjson library also support multithreaded JSON streaming through a large f
 smaller JSON documents in either [ndjson](http://ndjson.org) or [JSON lines](http://jsonlines.org)
 format. If your JSON documents all contain arrays or objects, we even support direct file
 concatenation without whitespace. The concatenated file has no size restrictions (including larger
-than 4GB), though each individual document must be less than 4GB.
+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 }
@@ -286,24 +595,81 @@ Here is a simple example, given "x.json" with this content:

 ```c++
 dom::parser parser;
-for (dom::element doc : 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
 -------------

-The simdjson library is mostly single-threaded. Thread safety is the responsibility of the caller:
-it is unsafe to reuse a dom::parser object between different threads.
+We built simdjson with thread safety in mind.

-simdjson's CPU detection, which runs the first time parsing is attempted and switches to the fastest
+The simdjson library is single-threaded except for  [`parse_many`](parse_many.md) which may use secondary threads under its control when the library is compiled with thread support.
+
+
+We recommend using one `dom::parser` object per thread in which case the library is thread-safe.
+It is unsafe to reuse a `dom::parser` object between different threads.
+The parsed results (`dom::document`, `dom::element`, `array`, `object`) depend on the `dom::parser`, etc. therefore it is also potentially unsafe to use the result of the parsing between different threads.
+
+The CPU detection, which runs the first time parsing is attempted and switches to the fastest
 parser for your CPU, is transparent and thread-safe.

-The json stream parser is threaded, using a second thread under its own control. Like the single
-document parser
+
+Standard Compliance
+--------------------
+
+The simdjson library is fully compliant with  the [RFC 8259](https://www.tbray.org/ongoing/When/201x/2017/12/14/rfc8259.html) JSON specification.
+
+- 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. 
+  - 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.
+- The simdjson library accepts objects with repeated keys: all of the name/value pairs, including duplicates, are reported. We do not enforce key uniqueness.
+- The specification states that an implementation may set limits on the size of texts that it accepts. The simdjson library limits single JSON documents to 4 GiB. It will refuse to parse a JSON document larger than 4294967295 bytes. (This limitation does not apply to streams of JSON documents, only to single JSON documents.)
+- The specification states that an implementation may set limits on the maximum depth of nesting. By default, the simdjson will refuse to parse documents with a depth exceeding 1024.
+
+
+Backwards Compatibility
+-----------------------
+
+The only header file supported by simdjson is `simdjson.h`. Older versions of simdjson published a
+number of other include files such as `document.h` or `ParsedJson.h` alongside `simdjson.h`; these headers
+may be moved or removed in future versions.
@@ -0,0 +1,634 @@
+The Basics
+==========
+
+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.
+- 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
+------------------
+
+To include simdjson, copy the simdjson.h and simdjson.cpp files from the singleheader directory
+into your project. Then include the header file in your project with:
+
+```
+#include "simdjson.h"
+using namespace simdjson; // optional
+```
+
+You can compile with:
+
+```
+c++ myproject.cpp simdjson.cpp
+```
+
+Note:
+- Users on macOS and other platforms were default compilers do not provide C++11 compliant by default should request it with the appropriate flag (e.g., `c++  -std=c++17 myproject.cpp simdjson.cpp`).
+- Visual Studio users should compile with the `_CRT_SECURE_NO_WARNINGS` flag to avoid warnings with respect to our use of standard C functions such as `fopen`.
+
+Using simdjson with package managers
+------------------
+
+You can install the simdjson library on your system or in your project using multiple package managers such as  MSYS2, the conan package manager, vcpkg, brew, the apt package manager (debian-based Linux systems), the FreeBSD package manager (FreeBSD), and so on. [Visit our wiki for more details](https://github.com/simdjson/simdjson/wiki/Installing-simdjson-with-a-package-manager).
+
+Using simdjson as a CMake dependency
+------------------
+
+You can include the  simdjson as a CMake dependency by including the following lines in your `CMakeLists.txt`:
+
+```
+include(FetchContent)
+
+FetchContent_Declare(
+  simdjson
+  GIT_REPOSITORY https://github.com/simdjson/simdjson.git
+  GIT_TAG  v0.4.7
+  GIT_SHALLOW TRUE)
+
+set(SIMDJSON_JUST_LIBRARY ON CACHE INTERNAL "")
+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, 
+
+Elsewhere in your project, you can  declare dependencies on simdjson with lines such as these:
+
+```
+add_executable(myprogram myprogram.cpp)
+target_link_libraries(myprogram simdjson)
+```
+
+We recommend CMake version 3.15 or better.
+
+See [our CMake demonstration](https://github.com/simdjson/cmake_demo_single_file). It works under Linux, FreeBSD, macOS and Windows (including Visual Studio).
+
+The CMake build in simdjson can be taylored with a few variables. You can see the available variables and their default values by entering the `cmake -LA` command.
+
+
+
+The Basics: Loading and Parsing JSON Documents
+----------------------------------------------
+
+The simdjson library offers a simple DOM tree API, which you can access by creating a
+`dom::parser` and calling the `load()` method:
+
+```
+dom::parser parser;
+dom::element doc = parser.load(filename); // load and parse a file
+```
+
+Or by creating a padded string (for efficiency reasons, simdjson requires a string with
+SIMDJSON_PADDING bytes at the end) and calling `parse()`:
+
+```
+dom::parser parser;
+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.
+
+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. 
+
+
+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
+---------------------
+
+Once you have an element, you can navigate it with idiomatic C++ iterators, operators and casts.
+
+* **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 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;
+  simdjson::padded_string numberstring = "1.2"_padded; // our JSON input ("1.2")
+  simdjson::dom::parser parser;
+  double value; // variable where we store the value to be parsed
+  error = parser.parse(numberstring).get(value);
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+  std::cout << "I parsed " << value << " from " << numberstring.data() << std::endl;
+  ```
+* **Field Access:** To get the value of the "foo" field in an object, use `object["foo"]`.
+* **Array Iteration:** To iterate through an array, use `for (auto value : array) { ... }`. If you
+  know the type of the value, you can cast it right there, too! `for (double value : array) { ... }`
+* **Object Iteration:** You can iterate through an object's fields, too: `for (auto [key, value] : object)`
+* **Array Index:** To get at an array value by index, use the at() method: `array.at(0)` gets the
+  first element.
+  > Note that array[0] does not compile, because implementing [] gives the impression indexing is a
+  > O(1) operation, which it is not presently in simdjson. Instead, you should iterate over the elements
+  > using a for-loop, as in our examples.
+* **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` 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)`).
+
+
+The following code illustrates all of the above:
+
+```
+auto cars_json = R"( [
+  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
+  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
+  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
+] )"_padded;
+dom::parser parser;
+
+// Iterating through an array of objects
+for (dom::object car : parser.parse(cars_json)) {
+  // Accessing a field by name
+  cout << "Make/Model: " << car["make"] << "/" << car["model"] << endl;
+
+  // Casting a JSON element to an integer
+  uint64_t year = car["year"];
+  cout << "- This car is " << 2020 - year << "years old." << endl;
+
+  // Iterating through an array of floats
+  double total_tire_pressure = 0;
+  for (double tire_pressure : car["tire_pressure"]) {
+    total_tire_pressure += tire_pressure;
+  }
+  cout << "- Average tire pressure: " << (total_tire_pressure / 4) << endl;
+
+  // Writing out all the information about the car
+  for (auto field : car) {
+    cout << "- " << field.key << ": " << field.value << endl;
+  }
+}
+```
+
+Here is a different example illustrating the same ideas:
+
+```
+auto abstract_json = R"( [
+    {  "12345" : {"a":12.34, "b":56.78, "c": 9998877}   },
+    {  "12545" : {"a":11.44, "b":12.78, "c": 11111111}  }
+  ] )"_padded;
+dom::parser parser;
+
+// Parse and iterate through an array of objects
+for (dom::object obj : parser.parse(abstract_json)) {
+    for(const auto& key_value : obj) {
+      cout << "key: " << key_value.key << " : ";
+      dom::object innerobj = key_value.value;
+      cout << "a: " << double(innerobj["a"]) << ", ";
+      cout << "b: " << double(innerobj["b"]) << ", ";
+      cout << "c: " << int64_t(innerobj["c"]) << endl;
+    }
+}
+```
+
+And another one:
+
+
+```
+  auto abstract_json = R"(
+    {  "str" : { "123" : {"abc" : 3.14 } } } )"_padded;
+  dom::parser parser;
+  double v = parser.parse(abstract_json)["str"]["123"]["abc"];
+  cout << "number: " << v << endl;
+```
+
+
+C++11 Support and string_view
+-------------
+
+The simdjson library builds on compilers supporting the [C++11 standard](https://en.wikipedia.org/wiki/C%2B%2B11). It is also a strict requirement: we have no plan to support older C++ compilers.
+
+We represent parsed strings in simdjson using the `std::string_view` class. It avoids
+the need to copy the data, as would be necessary with the `std::string` class. It also
+avoids the pitfalls of null-terminated C strings.
+
+The `std::string_view` class has become standard as part of C++17 but it is not always available
+on compilers which only supports C++11. When we detect that `string_view` is natively
+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  
+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`.
+
+
+C++17 Support
+-------------
+
+While the simdjson library can be used in any project using C++ 11 and above, field iteration has special support C++ 17's destructuring syntax. For example:
+
+```
+padded_string json = R"(  { "foo": 1, "bar": 2 }  )"_padded;
+dom::parser parser;
+dom::object object;
+auto error = parser.parse(json).get(object);
+if (error) { cerr << error << endl; return; }
+for (auto [key, value] : object) {
+  cout << key << " = " << value << endl;
+}
+```
+
+For comparison, here is the C++ 11 version of the same code:
+
+```
+// C++ 11 version for comparison
+padded_string json = R"(  { "foo": 1, "bar": 2 }  )"_padded;
+dom::parser parser;
+dom::object object;
+auto error = parser.parse(json).get(object);
+if (!error) { cerr << error << endl; return; }
+for (dom::key_value_pair field : object) {
+  cout << field.key << " = " << field.value << endl;
+}
+```
+
+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 (`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 = 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.
+```
+
+Though it does not validate the JSON input, it will detect when the document ends with an unterminated string. E.g., it would refuse to minify the string `"this string is not terminated` because of the missing final quote.
+
+
+UTF-8 validation (alone)
+----------------------
+
+The simdjson library has fast functions to validate UTF-8 strings. They are many times faster than most functions commonly found in libraries. You can use our fast functions, even if you do not care about JSON.
+
+```
+  const char * some_string = "[ 1, 2, 3, 4] ";
+  size_t length = std::strlen(some_string);
+  bool is_ok = simdjson::validate_utf8(some_string, length);
+```
+
+The UTF-8 validation function merely checks that the input is valid UTF-8: it works with strings in general, not just JSON strings.
+
+Your input string does not need any padding. Any string will do. The `validate_utf8` function does not do any memory allocation on the heap, and it does not throw exceptions.
+
+JSON Pointer
+------------
+
+The simdjson library also supports [JSON pointer](https://tools.ietf.org/html/rfc6901) through the
+`at_pointer()` method, letting you reach further down into the document in a single call:
+
+```c++
+auto cars_json = R"( [
+  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
+  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
+  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
+] )"_padded;
+dom::parser parser;
+dom::element cars = parser.parse(cars_json);
+cout << cars.at_pointer("/0/tire_pressure/1") << endl; // Prints 39.9
+```
+
+A JSON Path is a sequence of segments each starting with the '/' character. Within arrays, an integer
+index allows you to select the indexed node. Within objects, the string value of the key allows you to
+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.  
+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: 
+
+```c++
+auto cars_json = R"( [
+  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
+  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
+  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
+] )"_padded;
+dom::parser parser;
+dom::element cars = parser.parse(cars_json);
+cout << cars.at_pointer("/0/tire_pressure/1") << endl; // Prints 39.9
+for (dom::element car_element : cars) {
+    dom::object car;
+    simdjson::error_code error;
+    if ((error = car_element.get(car))) { std::cerr << error << std::endl; return; }
+    double x = car.at_pointer("/tire_pressure/1");
+    cout << x << endl; // Prints 39.9, 31 and 30
+}
+```
+
+
+Error Handling
+--------------
+
+All simdjson APIs that can fail return `simdjson_result<T>`, which is a &lt;value, error_code&gt;
+pair. You can retrieve the value with .get(), like so:
+
+```
+dom::element doc;
+auto error = parser.parse(json).get(doc);
+if (error) { cerr << error << endl; exit(1); }
+```
+
+When you use the code this way, it is your responsibility to check for error before using the
+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:
+
+```
+#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; }
+
+  simdjson::dom::element res;
+  if ((error = tweets["search_metadata"]["count"].get(res))) {
+    std::cerr << "could not access keys" << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout << res << " results." << std::endl;
+}
+```
+
+### Error Handling Example
+
+This is how the example in "Using the Parsed JSON" could be written using only error code checking:
+
+```
+auto cars_json = R"( [
+  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
+  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
+  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
+] )"_padded;
+dom::parser parser;
+dom::array cars;
+auto error = parser.parse(cars_json).get(cars);
+if (error) { cerr << error << endl; exit(1); }
+
+// Iterating through an array of objects
+for (dom::element car_element : cars) {
+    dom::object car;
+    if ((error = car_element.get(car))) { cerr << error << endl; exit(1); }
+
+    // Accessing a field by name
+    std::string_view make, model;
+    if ((error = car["make"].get(make))) { cerr << error << endl; exit(1); }
+    if ((error = car["model"].get(model))) { cerr << error << endl; exit(1); }
+    cout << "Make/Model: " << make << "/" << model << endl;
+
+    // Casting a JSON element to an integer
+    uint64_t year;
+    if ((error = car["year"].get(year))) { cerr << error << endl; exit(1); }
+    cout << "- This car is " << 2020 - year << "years old." << endl;
+
+    // Iterating through an array of floats
+    double total_tire_pressure = 0;
+    dom::array tire_pressure_array;
+    if ((error = car["tire_pressure"].get(tire_pressure_array))) { cerr << error << endl; exit(1); }
+    for (dom::element tire_pressure_element : tire_pressure_array) {
+        double tire_pressure;
+        if ((error = tire_pressure_element.get(tire_pressure))) { cerr << error << endl; exit(1); }
+        total_tire_pressure += tire_pressure;
+    }
+    cout << "- Average tire pressure: " << (total_tire_pressure / 4) << endl;
+
+    // Writing out all the information about the car
+    for (auto field : car) {
+        cout << "- " << field.key << ": " << field.value << endl;
+    }
+}
+```
+
+Here is another example:
+
+```
+auto abstract_json = R"( [
+    {  "12345" : {"a":12.34, "b":56.78, "c": 9998877}   },
+    {  "12545" : {"a":11.44, "b":12.78, "c": 11111111}  }
+  ] )"_padded;
+dom::parser parser;
+dom::array array;
+auto error = parser.parse(abstract_json).get(array);
+if (error) { cerr << error << endl; exit(1); }
+// Iterate through an array of objects
+for (dom::element elem : array) {
+    dom::object obj;
+    if ((error = elem.get(obj))) { cerr << error << endl; exit(1); }
+    for (auto & key_value : obj) {
+        cout << "key: " << key_value.key << " : ";
+        dom::object innerobj;
+        if ((error = key_value.value.get(innerobj))) { cerr << error << endl; exit(1); }
+
+        double va, vb;
+        if ((error = innerobj["a"].get(va))) { cerr << error << endl; exit(1); }
+        cout << "a: " << va << ", ";
+        if ((error = innerobj["b"].get(vc))) { cerr << error << endl; exit(1); }
+        cout << "b: " << vb << ", ";
+
+        int64_t vc;
+        if ((error = innerobj["c"].get(vc))) { cerr << error << endl; exit(1); }
+        cout << "c: " << vc << endl;
+    }
+}
+```
+
+And another one:
+
+```
+  auto abstract_json = R"(
+    {  "str" : { "123" : {"abc" : 3.14 } } } )"_padded;
+  dom::parser parser;
+  double v;
+  auto error = parser.parse(abstract_json)["str"]["123"]["abc"].get(v);
+  if (error) { cerr << error << endl; exit(1); }
+  cout << "number: " << v << endl;
+```
+
+Notice how we can string several operations (`parser.parse(abstract_json)["str"]["123"]["abc"].get(v)`) and only check for the error once, a strategy we call  *error chaining*.
+
+The next two functions will take as input a JSON document containing an array with a single element, either a string or a number. They return true upon success.
+
+```
+simdjson::dom::parser parser{};
+
+bool parse_double(const char *j, double &d) {
+  auto error = parser.parse(j, std::strlen(j))
+        .at(0)
+        .get(d, error);
+  if (error) { return false; }
+  return true;
+}
+
+bool parse_string(const char *j, std::string &s) {
+  std::string_view answer;
+  auto error = parser.parse(j,strlen(j))
+        .at(0)
+        .get(answer, error);
+  if (error) { return false; }
+  s.assign(answer.data(), answer.size());
+  return true;
+}
+```
+
+### Exceptions
+
+Users more comfortable with an exception flow may choose to directly cast the `simdjson_result<T>` to the desired type:
+
+```
+dom::element doc = parser.parse(json); // Throws an exception if there was an error!
+```
+
+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.
+
+Tree Walking and JSON Element Types
+-----------------------------------
+
+Sometimes you don't necessarily have a document with a known type, and are trying to generically
+inspect or walk over JSON elements. To do that, you can use iterators and the type() method. For
+example, here's a quick and dirty recursive function that verbosely prints the JSON document as JSON
+(* ignoring nuances like trailing commas and escaping strings, for brevity's sake):
+
+```
+void print_json(dom::element element) {
+  switch (element.type()) {
+    case dom::element_type::ARRAY:
+      cout << "[";
+      for (dom::element child : dom::array(element)) {
+        print_json(child);
+        cout << ",";
+      }
+      cout << "]";
+      break;
+    case dom::element_type::OBJECT:
+      cout << "{";
+      for (dom::key_value_pair field : dom::object(element)) {
+        cout << "\"" << field.key << "\": ";
+        print_json(field.value);
+      }
+      cout << "}";
+      break;
+    case dom::element_type::INT64:
+      cout << int64_t(element) << endl;
+      break;
+    case dom::element_type::UINT64:
+      cout << uint64_t(element) << endl;
+      break;
+    case dom::element_type::DOUBLE:
+      cout << double(element) << endl;
+      break;
+    case dom::element_type::STRING:
+      cout << std::string_view(element) << endl;
+      break;
+    case dom::element_type::BOOL:
+      cout << bool(element) << endl;
+      break;
+    case dom::element_type::NULL_VALUE:
+      cout << "null" << endl;
+      break;
+  }
+}
+
+void basics_treewalk_1() {
+  dom::parser parser;
+  print_json(parser.load("twitter.json"));
+}
+```
+
+Newline-Delimited JSON (ndjson) and JSON lines
+----------------------------------------------
+
+The simdjson library also support multithreaded JSON streaming through a large file containing many
+smaller JSON documents in either [ndjson](http://ndjson.org) or [JSON lines](http://jsonlines.org)
+format. If your JSON documents all contain arrays or objects, we even support direct file
+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:
+
+```
+{ "foo": 1 }
+{ "foo": 2 }
+{ "foo": 3 }
+```
+
+```
+dom::parser parser;
+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)`: 
+
+
+```
+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.
+
+
+Thread Safety
+-------------
+
+We built simdjson with thread safety in mind.
+
+The simdjson library is single-threaded except for  `parse_many` which may use secondary threads under its control when the library is compiled with thread support.
+
+
+We recommend using one `dom::parser` object per thread in which case the library is thread-safe.
+It is unsafe to reuse a `dom::parser` object between different threads.
+The parsed results (`dom::document`, `dom::element`, `array`, `object`) depend on the `dom::parser`, etc. therefore it is also potentially unsafe to use the result of the parsing between different threads.
+
+The CPU detection, which runs the first time parsing is attempted and switches to the fastest
+parser for your CPU, is transparent and thread-safe.
+
+Backwards Compatibility
+-----------------------
+
+The only header file supported by simdjson is `simdjson.h`. Older versions of simdjson published a
+number of other include files such as `document.h` or `ParsedJson.h` alongside `simdjson.h`; these headers
+may be moved or removed in future versions.
@@ -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
 --------
@@ -47,7 +48,7 @@ Inspecting the Detected Implementation
 You can check what implementation is running with `active_implementation`:

 ```c++
-cout << "simdjson v" << #SIMDJSON_VERSION << endl;
+cout << "simdjson v" << STRINGIFY(SIMDJSON_VERSION) << endl;
 cout << "Detected the best implementation for your machine: " << simdjson::active_implementation->name();
 cout << "(" << simdjson::active_implementation->description() << ")" << endl;
 ```
@@ -70,6 +71,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 +90,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
+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), `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
@@ -12,31 +12,29 @@ Contents
 - [How it works](#how-it-works)
 - [Support](#support)
 - [API](#api)
- [Concurrency mode](#concurrency-mode)
- [Example](#example)
 - [Use cases](#use-cases)

-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 
+when encoded -- roughly one gigabyte.  It is often desirable to process such a dataset incrementally
 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
@@ -73,7 +71,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.
@@ -88,14 +86,21 @@ sweet spot for now.

 ### Threads

-But how can we make use of threads?  We found a pretty cool algorithm that allows us to quickly
+But how can we make use of threads if they are available?  We found a pretty cool algorithm that allows us to quickly
 identify the  position of the last JSON document in a given batch. Knowing exactly where the end of
 the batch is, we no longer need for stage 2 to finish in order to load a new batch. We already know
 where to start the next batch. Therefore, we can run stage 1 on the next batch concurrently while
-the main thread is going through stage 2. Now, running stage 1 in a different thread can, in best
-cases, remove almost entirely it's cost and replaces it by the overhead of a thread, which is orders
+the main thread is going through stage 2. Running stage 1 in a different thread can, in best
+cases, remove almost entirely its cost and replaces it by the overhead of a thread, which is orders
 of magnitude cheaper. Ain't that awesome!

+Thread support is only active if thread supported is detected in which case the macro
+SIMDJSON_THREADS_ENABLED is set. Otherwise the library runs in  single-thread mode.
+
+A `document_stream` instance uses at most two threads: there is a main thread and a worker thread.
+You should expect the main thread to be fully occupied while the worker thread is partially busy
+(e.g., 80% of the time).
+
 Support
 -------

@@ -104,7 +109,7 @@ format, we support any file that contains any amount of valid JSON document, **s
 or more character that is considered whitespace** by the JSON spec. Anything that is
 not whitespace will be parsed as a JSON document and could lead to failure.

-Whitespace Characters: 
+Whitespace Characters:
 - **Space**
 - **Linefeed**
 - **Carriage return**
@@ -132,16 +137,16 @@ From [jsonlines.org](http://jsonlines.org/examples/):
    ["Gilbert", "2013", 24, true]
    ["Alexa", "2013", 29, true]
    ["May", "2012B", 14, false]
-    ["Deloise", "2012A", 19, true] 
+    ["Deloise", "2012A", 19, true]
    ```
-    CSV seems so easy that many programmers have written code to generate it themselves, and almost every implementation is 
-    different. Handling broken CSV files is a common and frustrating task. CSV has no standard encoding, no standard column 
+    CSV seems so easy that many programmers have written code to generate it themselves, and almost every implementation is
+    different. Handling broken CSV files is a common and frustrating task. CSV has no standard encoding, no standard column
    separator and multiple character escaping standards. String is the only type supported for cell values, so some programs
     attempt to guess the correct types.
-    
+
    JSON Lines handles tabular data cleanly and without ambiguity. Cells may use the standard JSON types.
-    
-    The biggest missing piece is an import/export filter for popular spreadsheet programs so that non-programmers can use 
+
+    The biggest missing piece is an import/export filter for popular spreadsheet programs so that non-programmers can use
    this format.

 - **Easy Nested Data**
@@ -151,5 +156,5 @@ From [jsonlines.org](http://jsonlines.org/examples/):
    {"name": "May", "wins": []}
    {"name": "Deloise", "wins": [["three of a kind", "5♣"]]}
    ```
-    JSON Lines' biggest strength is in handling lots of similar nested data structures. One .jsonl file is easier to 
+    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.
@@ -8,14 +8,20 @@ are still some scenarios where tuning can enhance performance.
  * [Keeping documents around for longer](#keeping-documents-around-for-longer)
 * [Server Loops: Long-Running Processes and Memory Capacity](#server-loops-long-running-processes-and-memory-capacity)
 * [Large files and huge page support](#large-files-and-huge-page-support)
-* [Computed GOTOs](#computed-gotos)
+* [Number parsing](#number-parsing)
+* [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
 -----------------------------------------

 If you're using simdjson to parse multiple documents, or in a loop, you should make a parser once
 and reuse it. The simdjson library will allocate and retain internal buffers between parses, keeping
-buffers hot in cache and keeping memory allocation and initialization to a minimum.
+buffers hot in cache and keeping memory allocation and initialization to a minimum. In this manner,
+you can parse terabytes of JSON data without doing any new allocation.

 ```c++
 dom::parser parser;
@@ -35,7 +41,7 @@ cout << doc << endl;
 cout << doc2 << endl;
 ```

-It's not just internal buffers though. The simdjson library reuses the document itself. dom::element, dom::object and dom::array are *references* to the internal document.
+It's not just internal buffers though. The simdjson library reuses the document itself. The dom::element, dom::object and dom::array instances are *references* to the internal document.
 You are only *borrowing* the document from simdjson, which purposely reuses and overwrites it each
 time you call parse. This prevent wasteful and unnecessary memory allocation in 99% of cases where
 JSON is just read, used, and converted to native values or thrown away.
@@ -61,9 +67,10 @@ without bound:
 * You can set a *max capacity* when constructing a parser:

  ```c++
-  dom::parser parser(1024*1024); // Never grow past documents > 1MB
+  dom::parser parser(1000*1000); // Never grow past documents > 1MB
  for (web_request request : listen()) {
-    auto [doc, error] = parser.parse(request.body);
+    dom::element doc;
+    auto error = parser.parse(request.body).get(doc);
    // If the document was above our limit, emit 413 = payload too large
    if (error == CAPACITY) { request.respond(413); continue; }
    // ...
@@ -77,11 +84,12 @@ without bound:

  ```c++
  dom::parser parser(0); // This parser will refuse to automatically grow capacity
-  simdjson::error_code allocate_error = parser.allocate(1024*1024); // This allocates enough capacity to handle documents <= 1MB
-  if (allocate_error) { cerr << allocate_error << endl; exit(1); }
+  auto error = parser.allocate(1000*1000); // This allocates enough capacity to handle documents <= 1MB
+  if (error) { cerr << error << endl; exit(1); }

  for (web_request request : listen()) {
-    auto [doc, error] = parser.parse(request.body);
+    dom::element doc;
+    error = parser.parse(request.body).get(doc);
    // If the document was above our limit, emit 413 = payload too large
    if (error == CAPACITY) { request.respond(413); continue; }
    // ...
@@ -115,18 +123,6 @@ use the `-H` flag to omit the memory allocation cost from the benchmark results.
 ./parse -H largefile # without memory allocation
 ```

-Computed GOTOs
--------------
-
-For best performance, we use a technique called "computed goto" when the compiler supports it, it is
-also sometimes described as "Labels as Values". Though it is not part of the C++ standard, it is
-supported by many major compilers and it brings measurable performance benefits that are difficult
-to achieve otherwise. The computed gotos are  automatically disabled under Visual Studio.
-
-If you wish to forcefully disable computed gotos, you can do so by compiling the code with
-`-DSIMDJSON_NO_COMPUTED_GOTO=1`. It is not recommended to disable computed gotos if your compiler
-supports it. In fact, you should almost never need to be concerned with computed gotos.
-
 Number parsing
 --------------

@@ -140,3 +136,65 @@ few hundred megabytes per second if your JSON documents are densely packed with
 - When possible, you should favor integer values written without a decimal point, as it simpler and faster to parse decimal integer values.
 - When serializing numbers, you should not use more digits than necessary: 17 digits is all that is needed to exactly represent double-precision floating-point numbers. Using many more digits than necessary will make your files larger and slower to parse.
 - When benchmarking parsing speeds, always report whether your JSON documents are made mostly of floating-point numbers when it is the case, since number parsing can then dominate the parsing time.
+
+
+Visual Studio
+--------------
+
+On Intel and AMD Windows platforms, Microsoft Visual Studio enables programmers to build either 32-bit (x86) or 64-bit (x64) binaries. We urge you to always use 64-bit mode. Visual Studio 2019 should default on 64-bit builds when you have a 64-bit version of Windows, which we recommend.
+
+When compiling with Visual Studio, we recommend the flags `/Ob2 /O2` or better. We do not recommend that you compile simdjson with architecture-specific flags such as  `arch:AVX2`. The simdjson library automatically selects the best execution kernel at runtime.
+
+Recent versions of Microsoft Visual Studio on Windows provides support for the LLVM Clang compiler. You  only need to install the "Clang compiler" optional component (ClangCL). You may also get a copy of the 64-bit LLVM CLang compiler for [Windows directly from LLVM](https://releases.llvm.org/download.html). The simdjson library fully supports the LLVM Clang compiler under Windows. In fact, you may get better performance out of simdjson with the LLVM Clang compiler than with the regular Visual Studio compiler. Meanwhile the [LLVM CLang compiler is binary compatible with Visual Studio](https://clang.llvm.org/docs/MSVCCompatibility.html) which means that you can combine their binaries (executables and libraries).
+
+Under Windows, we also support the GNU GCC compiler via MSYS2. The performance of 64-bit MSYS2 under Windows excellent (on par with Linux).
+
+
+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. 
+
+
+You should not expect the simdjson library to cause *downclocking* of your recent Intel CPU cores.
+
+On some Intel processors, using SIMD instructions in a sustained manner on the same CPU core may result in a phenomenon called downclocking whereas the processor initially runs these instructions at a slow speed before reducing the frequency of the core for a short time (milliseconds). Intel refers to these states as licenses. On some current Intel processors, it occurs under two scenarios:
+
+- [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. 
+
+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.
+
+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.
@@ -134,4 +134,3 @@ In-between these two tape elements, we alternate between key (which must be stri
 All the content of the object is located between these two tape elements, including arrays and objects. 

 Performance consideration: We can skip the content of an object entirely by accessing the first 64-bit tape element, reading the payload and moving to the corresponding index on the tape.
- 
@@ -0,0 +1 @@
+add_subdirectory(quickstart)
@@ -0,0 +1,60 @@
+#
+# Quickstart compile tests don't require any flags
+#
+
+# TODO haven't quite decided the right way to run quickstart on Windows. Needs README update.
+#
+# Note: on macOS and other platforms, the 'command' described below may not work even if the cmake builds.
+# For example, it may be necessary to specify the sysroot, which CMake does, but the 'command' does not
+# handle such niceties. On a case-by-case basis it is fixable but it requires work that CMake knows how
+# to do but that is not trivial.
+#
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+  # TODO run amalgamate first!
+  function(add_quickstart_test TEST_NAME SOURCE_FILE)
+    # Second argument is C++ standard name
+    if (MSVC)
+      if (ARGV2)
+        set(QUICKSTART_FLAGS /std:${ARGV2})
+      else()
+        set(QUICKSTART_FLAGS /WX)
+      endif()
+      set(QUICKSTART_INCLUDE /I${PROJECT_SOURCE_DIR}/include /I${PROJECT_SOURCE_DIR}/src ${PROJECT_SOURCE_DIR}/src/simdjson.cpp)
+    else()
+      if (ARGV2)
+        set(QUICKSTART_FLAGS -Werror -std=${ARGV2})
+      else()
+        set(QUICKSTART_FLAGS -Werror)
+      endif()
+      set(QUICKSTART_INCLUDE -I${PROJECT_SOURCE_DIR}/include -I${PROJECT_SOURCE_DIR}/src ${PROJECT_SOURCE_DIR}/src/simdjson.cpp)
+    endif()
+
+    # Third argument tells whether to compile with -fno-exceptions
+    if (ARGV3)
+      if (NOT MSVC)
+        set(QUICKSTART_FLAGS ${QUICKSTART_FLAGS} -fno-exceptions)
+      endif()
+    endif()
+
+    add_test(
+      NAME ${TEST_NAME}
+      COMMAND ${CMAKE_CXX_COMPILER} ${QUICKSTART_FLAGS} -I${PROJECT_SOURCE_DIR}/include -I${PROJECT_SOURCE_DIR}/src ${PROJECT_SOURCE_DIR}/src/simdjson.cpp ${SOURCE_FILE}
+      WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/examples/quickstart
+    )
+    set_property(
+      TEST ${TEST_NAME}
+      APPEND PROPERTY DEPENDS simdjson-source ${PROJECT_SOURCE_DIR}/examples/quickstart/${SOURCE_FILE}
+    )
+  endfunction(add_quickstart_test)
+
+  if (SIMDJSON_EXCEPTIONS)
+    add_quickstart_test(quickstart quickstart.cpp)
+    add_quickstart_test(quickstart11 quickstart.cpp c++11)
+    add_quickstart_test(quickstart14 quickstart.cpp c++14)
+    set_property( TEST quickstart quickstart11 APPEND PROPERTY LABELS acceptance compiletests )
+  endif()
+
+  add_quickstart_test(quickstart_noexceptions quickstart_noexceptions.cpp "" true)
+  add_quickstart_test(quickstart_noexceptions11 quickstart_noexceptions.cpp c++11 true)
+  set_property( TEST quickstart_noexceptions APPEND PROPERTY LABELS acceptance compile )
+endif()
@@ -4,13 +4,29 @@ JSONEXAMPLES=$(ROOT)/jsonexamples

 test: quickstart twitter.json
 	./quickstart
+quickstart: quickstart.cpp simdjson.cpp simdjson.h
+	c++ -o ./quickstart quickstart.cpp simdjson.cpp
+clean:
+	rm -f simdjson.cpp simdjson.h twitter.json quickstart quickstart11 quickstart14
 simdjson.cpp: $(SINGLEHEADER)/simdjson.cpp
 	cp $(SINGLEHEADER)/simdjson.cpp .
 simdjson.h: $(SINGLEHEADER)/simdjson.h
 	cp $(SINGLEHEADER)/simdjson.h .
 twitter.json: $(JSONEXAMPLES)/twitter.json
 	cp $(JSONEXAMPLES)/twitter.json .
-quickstart: quickstart.cpp simdjson.cpp simdjson.h
-	c++ -o ./quickstart quickstart.cpp simdjson.cpp -std=c++17
-clean:
-	rm -f simdjson.cpp simdjson.h twitter.json quickstart
+
+quickstart11: $(ROOT)/src/**.h $(ROOT)/src/**.cpp $(ROOT)/include/**.h $(ROOT)/src/**.cpp
+	rm -f simdjson.h simdjson.cpp
+	c++ -o ./quickstart11 quickstart.cpp $(ROOT)/src/simdjson.cpp -I$(ROOT)/src -I$(ROOT)/include -std=c++11
+test11: quickstart11 twitter.json
+	./quickstart11
+quickstart14: $(ROOT)/src/**.h $(ROOT)/src/**.cpp $(ROOT)/include/**.h $(ROOT)/src/**.cpp
+	rm -f simdjson.h simdjson.cpp
+	c++ -o ./quickstart14 quickstart.cpp $(ROOT)/src/simdjson.cpp -I$(ROOT)/src -I$(ROOT)/include -std=c++14
+test14: quickstart14 twitter.json
+	./quickstart14
+quickstart17: $(ROOT)/src/**.h $(ROOT)/src/**.cpp $(ROOT)/include/**.h $(ROOT)/src/**.cpp
+	rm -f simdjson.h simdjson.cpp
+	c++ -o ./quickstart17 quickstart.cpp $(ROOT)/src/simdjson.cpp -I$(ROOT)/src -I$(ROOT)/include -std=c++17
+test17: quickstart17 twitter.json
+	./quickstart17
@@ -1,6 +1,7 @@
 #include "simdjson.h"
+
 int main(void) {
  simdjson::dom::parser parser;
  simdjson::dom::element tweets = parser.load("twitter.json");
  std::cout << tweets["search_metadata"]["count"] << " results." << std::endl;
-}
+}
@@ -0,0 +1,16 @@
+#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; }
+  simdjson::dom::element res;
+
+  if ((error = tweets["search_metadata"]["count"].get(res))) {
+    std::cerr << "could not access keys" << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout << res << " results." << std::endl;
+}
+
@@ -1,56 +1,68 @@
-# First attempt at a fuzzer, using libFuzzer.
-#
-# compile like this:
-# mkdir build-fuzzer
-# cd build-fuzzer
-# export LDFLAGS="-fsanitize=address,undefined"
-# export CXXFLAGS="-fsanitize=fuzzer-no-link,address,undefined"
-# export CFLAGS="-fsanitize=fuzzer-no-link,address,undefined"
-# export CXX=clang++
-# export CC=clang++
-# cmake .. -GNinja -DCMAKE_BUILD_TYPE=Debug -DENABLE_FUZZING=On -DSIMDJSON_FUZZ_LINKMAIN=Off -DSIMDJSON_FUZZ_LDFLAGS=-fsanitize=fuzzer
-# ninja
+option(ENABLE_FUZZING "enable building the fuzzers" ON)

+if(ENABLE_FUZZING)

-# settings this links in a main. useful for reproducing,
-# kcov, gdb, afl, valgrind.
-# (note that libFuzzer can also reproduce, just pass it the files)
-#
-# Using this by default, means the fuzzers will be built as a part of the normal
-# workflow, meaning they wont bitrot and will participate in refactoring etc.
-#
-option(SIMDJSON_FUZZ_LINKMAIN "links a main into fuzz targets for building reproducers" On)
+  # First attempt at a fuzzer, using libFuzzer.
+  #
+  # compile like this:
+  # mkdir build-fuzzer
+  # cd build-fuzzer
+  # export LDFLAGS="-fsanitize=address,undefined"
+  # export CXXFLAGS="-fsanitize=fuzzer-no-link,address,undefined"
+  # export CFLAGS="-fsanitize=fuzzer-no-link,address,undefined"
+  # export CXX=clang++
+  # export CC=clang++
+  # cmake .. -GNinja -DCMAKE_BUILD_TYPE=Debug -DENABLE_FUZZING=On -DSIMDJSON_FUZZ_LINKMAIN=Off -DSIMDJSON_FUZZ_LDFLAGS=-fsanitize=fuzzer
+  # ninja

-# For oss-fuzz - insert $LIB_FUZZING_ENGINE into the link flags, but only for
-# the fuzz targets, otherwise the cmake configuration step fails.
-set(SIMDJSON_FUZZ_LDFLAGS "" CACHE STRING "LDFLAGS for the fuzz targets")
+  # settings this links in a main. useful for reproducing,
+  # kcov, gdb, afl, valgrind.
+  # (note that libFuzzer can also reproduce, just pass it the files)
+  #
+  # Using this by default, means the fuzzers will be built as a part of the normal
+  # workflow, meaning they wont bitrot and will participate in refactoring etc.
+  #
+  option(SIMDJSON_FUZZ_LINKMAIN "links a main into fuzz targets for building reproducers" On)

-set(SOURCES
-  fuzz_parser.cpp
-#  fuzz_minify.cpp   # <--- does not pass the build check test on oss-fuzz, says "partially instrumented". help needed!
-  fuzz_dump.cpp
-  fuzz_print_json.cpp
-  fuzz_dump_raw_tape.cpp
-)
+  # For oss-fuzz - insert $LIB_FUZZING_ENGINE into the link flags, but only for
+  # the fuzz targets, otherwise the cmake configuration step fails.
+  set(SIMDJSON_FUZZ_LDFLAGS "" CACHE STRING "LDFLAGS for the fuzz targets")

-add_custom_target(print_all_fuzz_targets
-    COMMAND ${CMAKE_COMMAND} -E echo ${SOURCES}
-)
-
-macro(implement_fuzzer sourcefile)
-  get_filename_component(basename ${sourcefile} NAME_WE)
-  set(name ${basename})
-  add_executable(${name} ${sourcefile})
+  # Fuzzer build flags and libraries
+  add_library(simdjson-fuzzer INTERFACE)
  if (SIMDJSON_FUZZ_LINKMAIN)
-      target_sources(${name} PRIVATE main.cpp)
+    target_link_libraries(simdjson-fuzzer INTERFACE simdjson-source)
+    target_sources(simdjson-fuzzer INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>/main.cpp)
+  else ()
+    target_link_libraries(simdjson-fuzzer INTERFACE simdjson)
  endif ()
-  target_link_libraries(${name} PRIVATE ${SIMDJSON_LIB_NAME})
-if (SIMDJSON_FUZZ_LDFLAGS)
-  target_link_libraries(${name} PRIVATE ${SIMDJSON_FUZZ_LDFLAGS})
-endif ()
-endmacro ()
+  target_link_libraries(simdjson-fuzzer INTERFACE simdjson-internal-flags)
+  target_link_libraries(simdjson-fuzzer INTERFACE ${SIMDJSON_FUZZ_LDFLAGS})

-foreach (X IN ITEMS ${SOURCES})
-  implement_fuzzer(${X})
-endforeach ()
+  # Define the fuzzers
+  add_custom_target(all_fuzzers)

+  set(fuzzernames)
+  function(implement_fuzzer name)
+    add_executable(${name} ${name}.cpp)
+    target_link_libraries(${name} PRIVATE simdjson-fuzzer)
+    add_dependencies(all_fuzzers ${name})
+    set(fuzzernames ${fuzzernames} ${name} PARENT_SCOPE)
+  endfunction()
+
+  implement_fuzzer(fuzz_atpointer)
+  implement_fuzzer(fuzz_dump)
+  implement_fuzzer(fuzz_dump_raw_tape)
+  implement_fuzzer(fuzz_element)
+  implement_fuzzer(fuzz_implementations) # parses and serializes again, compares across implementations
+  implement_fuzzer(fuzz_minify)          # minify *with* parsing
+  implement_fuzzer(fuzz_minifyimpl)      # minify *without* parsing, plus compare implementations
+  implement_fuzzer(fuzz_parser)
+  implement_fuzzer(fuzz_print_json)
+  implement_fuzzer(fuzz_utf8)            # utf8 verification, compares across implementations
+
+  # to be able to get a list of all fuzzers from within a script
+  add_custom_target(print_all_fuzzernames
+    COMMAND ${CMAKE_COMMAND} -E echo ${fuzzernames})
+
+endif()
@@ -0,0 +1,158 @@
+#ifndef SIMDJSON_FUZZUTILS_H
+#define SIMDJSON_FUZZUTILS_H
+
+#include <cstdint>
+#include <vector>
+#include <string_view>
+#include <cstring> //memcpy
+
+// view data as a byte pointer
+template <typename T> inline const std::uint8_t* as_bytes(const T* data) {
+  return static_cast<const std::uint8_t*>(static_cast<const void*>(data));
+}
+
+// view data as a char pointer
+template <typename T> inline const char* as_chars(const T* data) {
+  return static_cast<const char*>(static_cast<const void*>(data));
+}
+
+
+
+
+// Splits the input into strings, using a four byte separator which is human
+// readable. Makes for nicer debugging of fuzz data.
+// See https://github.com/google/fuzzing/blob/master/docs/split-inputs.md#magic-separator
+// for background. Note: don't use memmem, it is not standard C++.
+inline std::vector<std::string_view> split(const char* Data, size_t Size) {
+
+  std::vector<std::string_view> ret;
+
+    using namespace std::literals;
+    constexpr auto sep="\n~~\n"sv;
+
+    std::string_view all(Data,Size);
+    auto pos=all.find(sep);
+    while(pos!=std::string_view::npos) {
+      ret.push_back(all.substr(0,pos));
+      all=all.substr(pos+sep.size());
+      pos=all.find(sep);
+    }
+    ret.push_back(all);
+    return ret;
+}
+
+// Generic helper to split fuzz data into usable parts, like ints etc.
+// Note that it does not throw, instead it sets the data pointer to null
+// if the input is exhausted.
+struct FuzzData {
+  // data may not be null, even if size is zero.
+  FuzzData(const uint8_t* data,
+           size_t size) : Data(data),Size(size){}
+
+  ///range is inclusive
+  template<int Min, int Max>
+  int getInt() {
+    static_assert (Min<Max,"min must be <max");
+
+    // make this constexpr, can't overflow because that is UB and is forbidden
+    // in constexpr evaluation
+    constexpr int range=(Max-Min)+1;
+    constexpr unsigned int urange=range;
+
+    // don't use std::uniform_int_distribution, we don't want to pay for
+    // over consumption of random data. Accept the slightly non-uniform distribution.
+    if(range<256)
+      return Min+static_cast<int>(get<uint8_t>()%urange);
+    if(range<65536)
+      return Min+static_cast<int>(get<uint16_t>()%urange);
+
+    return Min+static_cast<int>(get<uint32_t>()%urange);
+  }
+
+  template<typename T>
+  T get() {
+    const auto Nbytes=sizeof(T);
+    T ret{};
+    if(Size<Nbytes) {
+      //don't throw, signal with null instead.
+      Data=nullptr;
+      Size=0;
+      return ret;
+    }
+    std::memcpy(&ret,Data,Nbytes);
+    Data+=Nbytes;
+    Size-=Nbytes;
+    return ret;
+  }
+
+  // gets a string view with length in [Min,Max]
+  template<int Min, int Max>
+  std::string_view get_stringview() {
+    static_assert (Min>=0,"Min must be positive");
+    const int len=getInt<Min,Max>();
+    const unsigned int ulen=static_cast<unsigned int>(len);
+    if(ulen<Size) {
+      std::string_view ret(chardata(),ulen);
+      Data+=len;
+      Size-=ulen;
+      return ret;
+    }
+
+    //mark that there is too little data to fulfill the request
+    Data=nullptr;
+    Size=0;
+
+    return {};
+  }
+
+  // split the remainder of the data into string views,
+  std::vector<std::string_view> splitIntoStrings() {
+    std::vector<std::string_view> ret;
+    if(Size>0) {
+      ret=split(chardata(),Size);
+      // all data consumed.
+      Data+=Size;
+      Size=0;
+    }
+    return ret;
+  }
+
+  //are we good?
+  explicit operator bool() const { return Data!=nullptr;}
+
+  //we are a URBG
+  // https://en.cppreference.com/w/cpp/named_req/UniformRandomBitGenerator
+  //The type G satisfies UniformRandomBitGenerator if    Given
+  //   T, the type named by G::result_type
+  //    g, a value of type G
+  //
+  //  The following expressions must be valid and have their specified effects
+  //  Expression 	Return type 	Requirements
+  //  G::result_type 	T 	T is an unsigned integer type
+  using result_type=uint8_t;
+  //  G::min() 	T 	Returns the smallest value that G's operator() may return. The value is strictly less than G::max(). The function must be constexpr.
+  static constexpr result_type min() {return 0;}
+  //  G::max() 	T 	Returns the largest value that G's operator() may return. The value is strictly greater than G::min(). The function must be constexpr.
+  static constexpr result_type max() {return 255;}
+  //  g() 	T 	Returns a value in the closed interval [G::min(), G::max()]. Has amortized constant complexity.
+  result_type operator()() {
+    if(Size==0) {
+      // return something varying, otherwise uniform_int_distribution may get
+      // stuck
+      return failcount++;
+    }
+    const result_type ret=Data[0];
+    Data++;
+    Size--;
+    return ret;
+  }
+  // returns a pointer to data as const char* to avoid those cstyle casts
+  const char* chardata() const {return static_cast<const char*>(static_cast<const void*>(Data));}
+  // members
+  const uint8_t* Data;
+  size_t Size;
+  uint8_t failcount=0;
+};
+
+
+#endif // SIMDJSON_FUZZUTILS_H
@@ -2,72 +2,84 @@

 [Fuzzing](https://en.wikipedia.org/wiki/Fuzzing) is efficient for finding bugs. Here are a few bugs in simdjson found by fuzzing:

- - https://github.com/lemire/simdjson/issues/353
- - https://github.com/lemire/simdjson/issues/351
- - https://github.com/lemire/simdjson/issues/345
+ - [#353](https://github.com/simdjson/simdjson/issues/353)
+ - [#351](https://github.com/simdjson/simdjson/issues/351)
+ - [#345](https://github.com/simdjson/simdjson/issues/345)
+ - [oss-fuzz 18714](https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=18714&sort=-opened&q=proj%3Asimdjson&can=1)

 The simdjson library tries to follow [fuzzing best practises](https://google.github.io/oss-fuzz/advanced-topics/ideal-integration/#summary).

-The simdjson library is continuously fuzzed on [oss-fuzz](https://github.com/google/oss-fuzz).
+There is both "normal" fuzzers just feeding the api with fuzz data, as well as **differential** fuzzers. The differential fuzzers feed the same data to the multiple implementations (haswell, westmere and fallback) and ensure the same results are achieved. This makes sure the user will always get the same answer regardless of which implementation is in use.

+The fuzzers are used in several ways.

-## Currently open bugs
+* local fuzzing - for developers testing their changes before pushing and/or during development of the fuzzers themselves.
+* CI fuzzing - for weeding out those easy to find bugs in pull requests, before they are merged.
+* oss-fuzz - heavy duty 24/7 fuzzing provided by the google driven oss-fuzz project

-You can find the currently opened bugs, if any at [bugs.chromium.org](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&q=proj%3Asimdjson&can=2): make sure not to miss the "Open Issues" selector. Bugs that are fixed by follow-up commits are automatically closed.
+## Local fuzzing
+Just invoke fuzz/quick_check.sh, it will download the latest corpus from bintray (kept up to date by the CI fuzzers) and run the fuzzers for a short time. In case you want to run the fuzzers for longer, modify the timeout value in the script or invoke the fuzzer directly.

+This requires linux with clang and cmake installed (recent Debian and Ubuntu are known to work fine).

-## Fuzzing as a CI job
+It is also possible to run the full oss-fuzz setup by following [these oss-fuzz instructions](https://google.github.io/oss-fuzz/getting-started/new-project-guide/#testing-locally) with PROJECT_NAME set to simdjson. You will need rights to run docker.
+
+## Fuzzing as a CI job - x64

 There is a CI job which builds and runs the fuzzers. This is aimed to catch the "easy to fuzz" bugs quickly, without having to wait until pull requests are merged and eventually built and run by oss-fuzz.

 The CI job does the following
- - builds several variants (with/without avx, with/without sanitizers, a fast fuzzer)
+ - builds a fast fuzzer, with full optimization but less checks which is good at rapidly exploring the input space
+ - builds a heavily sanitized fuzzer, which is good at detecting errors
 - downloads the stored corpus
- - runs the fastest fuzzer build for 30 seconds, to grow the corpus
- - runs each build variant for 10 seconds on each fuzzer
- - using a reproduce build (uninstrumented), executes all the test cases in the corpus through valgrind
- - minimizes the corpus and upload it (if on the master branch)
- - store the corpus and valgrind output as artifacts
+ - runs the fast fuzzer build for a while, to grow the corpus
+ - runs the sanitizer fuzzer for a while, using the input found by the fast fuzzer
+ - using a reproduce build (uninstrumented), executes a subset of the test cases in the corpus through valgrind
+ - minimizes the corpus and uploads it (if on the master branch)
+ - stores the corpus and valgrind output as artifacts

-The job is available under the actions tab, here is a [direct link](https://github.com/lemire/simdjson/actions?query=workflow%3A%22Run+fuzzers+on+stored+corpus+and+test+it+with+valgrind%22).
+The job is available under the actions tab, here is a [direct link](https://github.com/simdjson/simdjson/actions?query=workflow%3A%22Fuzz+and+run+valgrind%22).
+
+The corpus will grow over time and easy to find bugs will be detected already during the pull request stage. Also, it will keep the fuzzer builds from bit rot.
+
+## Fuzzing as a CI job - arm64
+There is also a job running the fuzzers on arm64 (see .drone.yml) to make sure also the arm specific parts are fuzzed. This does not update the corpus, it just reuses what the x64 job finds.
+
+## Fuzzing on oss-fuzz
+The simdjson library is continuously fuzzed on [oss-fuzz](https://github.com/google/oss-fuzz). In case a bug is found, the offending input is minimized and tested for reproducibility. A report with the details is automatically filed, and the contact persons at simdjson are notified via email. An issue is opened at the oss-fuzz bugtracker with restricted view access. When the bug is fixed, the issue is automatically closed.
+
+Bugs are automatically made visible to the public after a period of time. An example of a bug that was found, fixed and closed can be seen here: [oss-fuzz 18714](https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=18714).
+
+
+## Currently open bugs
+
+You can find the currently open bugs (if any) at [bugs.chromium.org](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&q=proj%3Asimdjson&can=2): make sure not to miss the "Open Issues" selector. Bugs that are fixed by follow-up commits are automatically closed.
+
+## Integration with oss-fuzz
+
+Changes to the integration with oss-fuzz are made by making pull requests against the oss-fuzz github repo. An example can be seen at [oss-fuzz pull request 3013](https://github.com/google/oss-fuzz/pull/3013).
+
+As little code as possible is kept at oss-fuzz since it is inconvenient to change. The [oss-fuzz build script](https://github.com/google/oss-fuzz/blob/b96dd54183f727a5d90c786e0fb01ec986c74d30/projects/simdjson/build.sh#L18) invokes [the script from the simdjson repo](https://github.com/simdjson/simdjson/blob/master/fuzz/ossfuzz.sh).

-The corpus will grow over time and easy to find bugs will be detected already during the pull request stage. Also, it will keep the fuzzer builds from bit rot. 

 ## Corpus

-The simdjson library does not benefit from a corpus as much as other projects, because the library is very fast and explores the input space very well. With that said, it is still beneficial to have one. The CI job stores the corpus on bintray between runs, and is available here: https://dl.bintray.com/pauldreik/simdjson-fuzz-corpus/corpus/corpus.tar
+The simdjson library does not benefit from a corpus as much as other projects, because the library is very fast and explores the input space very well. With that said, it is still beneficial to have one. The CI job stores the corpus on bintray between runs, and is available at [bintray](https://dl.bintray.com/pauldreik/simdjson-fuzz-corpus/corpus/corpus.tar).

 One can also grab the corpus as an artifact from the github actions job. Pick a run, then go to artifacts and download.

 ## Fuzzing coverage

-The code coverage from fuzzing is most easily viewed on the [oss-fuzz status panel](https://oss-fuzz.com/fuzzer-stats). Viewing the coverage does not require login, but the direct link is publicly accessible. Substitute the date in the URL to get a more recent link:
-https://storage.googleapis.com/oss-fuzz-coverage/simdjson/reports/20191112/linux/src/simdjson/report.html
+The code coverage from fuzzing is most easily viewed on the [oss-fuzz status panel](https://oss-fuzz.com/fuzzer-stats). Viewing the coverage does not require login, but the direct link is not easy to find. Substitute the date in the URL to get a more recent link:
+[https://storage.googleapis.com/oss-fuzz-coverage/simdjson/reports/20200411/linux/src/simdjson/report.html](https://storage.googleapis.com/oss-fuzz-coverage/simdjson/reports/20200411/linux/src/simdjson/report.html)

-
-## Running the fuzzers locally
-
-Make sure you have clang and cmake installed.
-The easiest way to get started is to run the following, standing in the root of the checked out repo:
-```
-fuzz/build_like_ossfuzz.sh
-```
-
-Then invoke a fuzzer as shown by the following example:
-```
-mkdir -p out/parser
-build/fuzz/fuzz_parser out/parser/
-```
-
-You can also use the more extensive fuzzer build script to get a variation of builds by using
-```
-fuzz/build_fuzzer_variants.sh
-```
-
-It is also possible to run the full oss-fuzz setup by following [these oss-fuzz instructions](https://google.github.io/oss-fuzz/getting-started/new-project-guide/#testing-locally) with PROJECT_NAME set to simdjson.
+Keeping the coverage up is a never ending job. See [issue 368](https://github.com/simdjson/simdjson/issues/368)

 ## Reproducing
-To reproduce a test case, build the fuzzers, then invoke it with the testcase as a command line argument:
-```
-build/fuzz/fuzz_parser my_testcase.json
+To reproduce a test case, use the local build instruction. Then invoke the fuzzer (the fuzz_parser is shown as an example below) with the testcase as a command line argument:
+```shell
+fuzz/build_fuzzer_variants.sh
+build-sanitizers/fuzz/fuzz_parser my_testcase.json
 ```
+In case this does not reproduce the bug, you may want to proceed with reproducing using the oss-fuzz tools. See the instructions [here](https://google.github.io/oss-fuzz/advanced-topics/reproducing/).
+
@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-# Builds a corpus from all json files in the source directory.
+# Builds a corpus from all small json files in the source directory.
 # The files are renamed to the sha1 of their content, and suffixed
 # .json. The files are zipped into a flat file named corpus.zip

@@ -10,9 +10,9 @@ tmp=$(mktemp -d)

 root=$(readlink -f "$(dirname "$0")/..")

-find $root -type f -name "*.json" | while read -r json; do
+find $root -type f -size -4k -name "*.json" | while read -r json; do
 cp "$json" "$tmp"/$(sha1sum < "$json" |cut -f1 -d' ').json
 done

-zip --junk-paths -r corpus.zip "$tmp"
+zip --quiet --junk-paths -r corpus.zip "$tmp"
 rm -rf "$tmp"
@@ -12,151 +12,63 @@ unset CXX CC CFLAGS CXXFLAGS LDFLAGS

 me=$(basename $0)

-# A reproduce build, without avx but otherwise as plain
-# as it gets. No sanitizers or optimization.
-variant=plain-noavx
-if [ ! -d build-$variant ] ; then
-    mkdir build-$variant
-    cd build-$variant
-    
-    cmake .. \
-	  -GNinja \
-	  -DCMAKE_BUILD_TYPE=Debug \
-	  -DSIMDJSON_BUILD_STATIC=On \
-	  -DENABLE_FUZZING=On \
-	  -DSIMDJSON_FUZZ_LINKMAIN=On \
-	  -DSIMDJSON_IMPLEMENTATION_HASWELL=0
-    
-    ninja
-    cd ..
-fi
+# common options
+CLANGVER=-9
+COMMON="-GNinja -DCMAKE_CXX_COMPILER=clang++$CLANGVER -DCMAKE_C_COMPILER=clang$CLANGVER -DSIMDJSON_BUILD_STATIC=Off -DENABLE_FUZZING=On -DSIMDJSON_COMPETITION=OFF -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_GIT=Off"

-# A reproduce build as plain as it gets. Everythings tunable is
-# using the defaults.
-variant=plain-normal
+# A replay build, as plain as it gets. For use with valgrind/gdb.
+variant=replay
 if [ ! -d build-$variant ] ; then
    mkdir build-$variant
    cd build-$variant
    
    cmake .. \
-	  -GNinja \
+	  $COMMON \
 	  -DCMAKE_BUILD_TYPE=Debug \
-	  -DSIMDJSON_BUILD_STATIC=On \
-	  -DENABLE_FUZZING=On \
 	  -DSIMDJSON_FUZZ_LINKMAIN=On
    
-    ninja
-    cd ..
-fi
-
-# a fuzzer with sanitizers, built with avx disabled.
-variant=ossfuzz-noavx
-if [ ! -d build-$variant ] ; then
-    
-    export CC=clang
-    export CXX="clang++"
-    export CFLAGS="-fsanitize=fuzzer-no-link,address,undefined -fno-sanitize-recover=undefined -mno-avx2 -mno-avx "
-    export CXXFLAGS="-fsanitize=fuzzer-no-link,address,undefined -fno-sanitize-recover=undefined -mno-avx2 -mno-avx"
-    export LIB_FUZZING_ENGINE="-fsanitize=fuzzer"
-    
-    mkdir build-$variant
-    cd build-$variant
-    
-    cmake .. \
-	  -GNinja \
-	  -DCMAKE_BUILD_TYPE=Debug \
-	  -DSIMDJSON_BUILD_STATIC=On \
-	  -DENABLE_FUZZING=On \
-	  -DSIMDJSON_FUZZ_LINKMAIN=Off \
-	  -DSIMDJSON_FUZZ_LDFLAGS=$LIB_FUZZING_ENGINE \
-	  -DSIMDJSON_IMPLEMENTATION_HASWELL=0
-    
-    ninja
+    ninja all_fuzzers
    cd ..
 fi


-# a fuzzer with sanitizers, built with avx disabled.
-variant=ossfuzz-noavx8
-if which clang++-8 >/dev/null 2>&1 ; then
+# A fuzzer with sanitizers. For improved capability to find bugs.
+variant=sanitizers
+
    if [ ! -d build-$variant ] ; then
 	
-	export CC=clang-8
-	export CXX="clang++-8"
-	export CFLAGS="-fsanitize=fuzzer-no-link,address,undefined -fno-sanitize-recover=undefined -mno-avx2 -mno-avx "
-	export CXXFLAGS="-fsanitize=fuzzer-no-link,address,undefined -fno-sanitize-recover=undefined -mno-avx2 -mno-avx"
-	export LIB_FUZZING_ENGINE="-fsanitize=fuzzer"
-	
 	mkdir build-$variant
 	cd build-$variant
 	
 	cmake .. \
-	      -GNinja \
+	      $COMMON \
+	      -DCMAKE_CXX_FLAGS="-fsanitize=fuzzer-no-link,address,undefined -fno-sanitize-recover=undefined" \
+	      -DCMAKE_C_FLAGS="-fsanitize=fuzzer-no-link,address,undefined -fno-sanitize-recover=undefined" \
 	      -DCMAKE_BUILD_TYPE=Debug \
-	      -DSIMDJSON_BUILD_STATIC=On \
-	      -DENABLE_FUZZING=On \
 	      -DSIMDJSON_FUZZ_LINKMAIN=Off \
-	      -DSIMDJSON_FUZZ_LDFLAGS=$LIB_FUZZING_ENGINE \
-	      -DSIMDJSON_IMPLEMENTATION_HASWELL=0
+	      -DSIMDJSON_FUZZ_LDFLAGS="-fsanitize=fuzzer"
 	
-	ninja
+	ninja all_fuzzers
 	cd ..
    fi
-else
-    echo "$me: WARNING clang++-8 not found, please install it to build $variant"
-fi

-# a fuzzer with sanitizers, default built
-variant=ossfuzz-withavx
-if [ ! -d build-$variant ] ; then
-    
-    export CC=clang
-    export CXX="clang++"
-    export CFLAGS="-fsanitize=fuzzer-no-link,address,undefined -fno-sanitize-recover=undefined"
-    export CXXFLAGS="-fsanitize=fuzzer-no-link,address,undefined -fno-sanitize-recover=undefined"
-    export LIB_FUZZING_ENGINE="-fsanitize=fuzzer"
-    
-    mkdir build-$variant
-    cd build-$variant
-    
-    cmake .. \
-	  -GNinja \
-	  -DCMAKE_BUILD_TYPE=Debug \
-	  -DSIMDJSON_BUILD_STATIC=On \
-	  -DENABLE_FUZZING=On \
-	  -DSIMDJSON_FUZZ_LINKMAIN=Off \
-	  -DSIMDJSON_FUZZ_LDFLAGS=$LIB_FUZZING_ENGINE
-    
-    ninja
-    cd ..
-fi

-# a fast fuzzer, for fast exploration
-variant=ossfuzz-fast8
-if which clang++-8 >/dev/null 2>&1 ; then
-    if [ ! -d build-$variant ] ; then
-	export CC=clang-8
-	export CXX="clang++-8"
-	export CFLAGS="-fsanitize=fuzzer-no-link -O3 -g"
-	export CXXFLAGS="-fsanitize=fuzzer-no-link -O3 -g"
-	export LIB_FUZZING_ENGINE="-fsanitize=fuzzer"
+
+# A fast fuzzer, for fast exploration rather than finding bugs.
+variant=fast
+ if [ ! -d build-$variant ] ; then
 	
 	mkdir build-$variant
 	cd build-$variant
 	
 	cmake .. \
-	      -GNinja \
-	      -DCMAKE_BUILD_TYPE= \
-	      -DSIMDJSON_BUILD_STATIC=On \
-	      -DENABLE_FUZZING=On \
+	      $COMMON \
+	      -DCMAKE_CXX_FLAGS="-fsanitize=fuzzer-no-link" \
+	      -DCMAKE_C_FLAGS="-fsanitize=fuzzer-no-link" \
+	      -DCMAKE_BUILD_TYPE=Release \
 	      -DSIMDJSON_FUZZ_LINKMAIN=Off \
-	      -DSIMDJSON_FUZZ_LDFLAGS=$LIB_FUZZING_ENGINE
-	
-	ninja
+	      -DSIMDJSON_FUZZ_LDFLAGS="-fsanitize=fuzzer"
 	
+	ninja all_fuzzers
 	cd ..
    fi
-else
-    echo "$me: WARNING clang++-8 not found, please install it to build $variant"
-fi
-
--- a/Show More
+++ b/Show More